Travailler avec le système de fichiers en TypeScript : guide pratique

Introduction : pourquoi travailler avec le système de fichiers en TypeScript

TypeScript, étant un sur-ensemble strictement typé de JavaScript, offre aux développeurs des outils puissants pour travailler avec le système de fichiers. Que vous créiez un utilitaire de traitement de logs, un serveur web avec téléchargement de fichiers ou un outil de migration de données — savoir interagir efficacement avec le système de fichiers est une compétence de base.

Dans cet article, nous examinerons les aspects pratiques du travail avec le système de fichiers en TypeScript en utilisant le module intégré fs (File System) de Node.js. Tous les exemples seront accompagnés de commentaires et d'explications détaillés. Nous aborderons les méthodes synchrones et asynchrones, le travail avec les chemins et le typage des données.

1. Configuration du projet et importation du module fs

Avant de commencer, vous devez configurer un projet TypeScript. Assurez-vous d'avoir Node.js et le gestionnaire de paquets npm installés. Créez un nouveau projet et installez les types pour Node.js :

npm init -ynpm install typescript @types/node --save-devnpm install ts-node --save-dev

Créez un fichier tsconfig.json et ajoutez-y les configurations de base :

{  "compilerOptions": {    "target": "ES2020",    "module": "commonjs",    "strict": true,    "esModuleInterop": true,    "outDir": "./dist",    "rootDir": "./src"  },  "include": ["src/**/*"]}

Maintenant, dans votre fichier index.ts, importez les modules fs et path :

import * as fs from 'fs';import * as path from 'path';

Important : En TypeScript, nous utilisons import * as pour importer l'ensemble du module. Cela garantit un typage complet de toutes les méthodes.

2. Lecture de fichiers : approches synchrone et asynchrone

2.1 Lecture asynchrone (méthode recommandée)

En TypeScript, il est préférable d'utiliser des méthodes asynchrones, car elles ne bloquent pas le thread principal d'exécution. Voici un exemple de lecture d'un fichier texte :

import * as fs from 'fs/promises';import * as path from 'path';

async function readFileExample(filePath: string): Promise<string> {  try {    const absolutePath = path.resolve(filePath);    const content: string = await fs.readFile(absolutePath, 'utf-8');    return content;  } catch (error) {    if (error instanceof Error) {      throw new Error(`Erreur de lecture du fichier : ${error.message}`);    }    throw error;  }}

// Utilisation(async () => {  const data = await readFileExample('./data/example.txt');  console.log('Contenu du fichier :', data);})();

Notez l'utilisation de fs/promises — il s'agit de la version du module avec des promesses, qui s'intègre parfaitement avec async/await en TypeScript.

2.2 Lecture synchrone (pour les scénarios simples)

Parfois, par exemple lors du chargement de la configuration au démarrage, vous pouvez utiliser des méthodes synchrones :

import * as fs from 'fs';import * as path from 'path';

function readConfigSync(configPath: string): Record<string, unknown> {  const fullPath = path.join(__dirname, configPath);  const rawData = fs.readFileSync(fullPath, 'utf-8');  return JSON.parse(rawData);}

const config = readConfigSync('./config.json');console.log('Configuration :', config);

3. Écriture et modification de fichiers

3.1 Écriture de données dans un fichier

Pour écrire des données dans un fichier, utilisez writeFile. TypeScript permet de typer strictement les données avant l'écriture :

import * as fs from 'fs/promises';

interface UserData {  id: number;  name: string;  email: string;}

async function saveUserData(users: UserData[]): Promise<void> {  const jsonString: string = JSON.stringify(users, null, 2);  await fs.writeFile('./users.json', jsonString, 'utf-8');  con