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

Introduction au travail avec le système de fichiers en TypeScript

TypeScript est une extension fortement typée de JavaScript qui ajoute un typage statique et améliore la lisibilité et la maintenabilité du code. L'une des tâches clés lors du développement d'applications serveur est le travail avec le système de fichiers : lecture et écriture de fichiers, création et suppression de répertoires, gestion des flux de données. Dans cet article, nous allons détailler comment travailler efficacement avec le système de fichiers en TypeScript, en utilisant le module intégré fs de Node.js.

Le module fs fournit à la fois des méthodes synchrones et asynchrones pour interagir avec le système de fichiers. En TypeScript, nous pouvons tirer parti des avantages du typage pour rendre le code plus fiable et compréhensible. Nous examinerons les opérations de base, notamment la lecture, l'écriture, la vérification de l'existence des fichiers, le travail avec les répertoires et la gestion des erreurs.

Opérations de base avec les fichiers

Lecture de fichiers

Pour lire le contenu d'un fichier en TypeScript, on peut utiliser la méthode readFile (asynchrone) ou readFileSync (synchrone). L'approche asynchrone est recommandée pour une exécution non bloquante du programme.

import { readFile } from 'fs/promises';

async function readFileExample(filePath: string): Promise<string> {  try {    const data = await readFile(filePath, 'utf-8');    return data;  } catch (error) {    console.error('Erreur lors de la lecture du fichier :', error);    throw error;  }}

// UtilisationreadFileExample('example.txt').then(content => {  console.log('Contenu du fichier :', content);});

Notez l'utilisation de fs/promises — c'est un wrapper de promesses qui permet d'utiliser la syntaxe async/await. Le type de retour Promise<string> indique explicitement que la fonction retourne une chaîne de caractères.

Écriture dans les fichiers

L'écriture de données dans un fichier s'effectue avec les méthodes writeFile et writeFileSync. En TypeScript, il est important de gérer correctement les erreurs potentielles, surtout si le fichier est protégé en écriture ou si le chemin n'existe pas.

import { writeFile, mkdir } from 'fs/promises';import { existsSync } from 'fs';

async function writeFileExample(filePath: string, data: string): Promise<void> {  try {    // Vérifie si le répertoire existe    const dir = filePath.substring(0, filePath.lastIndexOf('/'));    if (dir && !existsSync(dir)) {      await mkdir(dir, { recursive: true });    }    await writeFile(filePath, data, 'utf-8');    console.log('Fichier écrit avec succès');  } catch (error) {    console.error('Erreur lors de l'écriture du fichier :', error);  }}

// UtilisationwriteFileExample('data/output.txt', 'Hello, TypeScript!');

Dans cet exemple, nous vérifions d'abord l'existence du répertoire et le créons si nécessaire avec mkdir et l'option recursive: true. Cela permet d'éviter l'erreur "ENOENT" si le dossier parent n'existe pas.

Ajout de données à la fin d'un fichier

Si vous devez ajouter des données à un fichier existant, utilisez la méthode appendFile :

import { appendFile } from 'fs/promises';

async function appendToFile(filePath: string, data: string): Promise<void> {  try {    await appendFile(filePath, '' + data, 'utf-8');    console.log('Données ajoutées');  } catch (error) {    console.error('Erreur lors de l'ajout :', error);  }}

Travail avec les répertoires

Création et suppression de répertoires

Pour créer des répertoires, on utilise mkdir, pour les supprimer — rmdir ou rm (pour une suppression récursive). En TypeScript, il est pratique d'utiliser les generics pour typer les chemins.

import { mkdir, rmdir, rm } from 'fs/promises';import { existsSync } from 'fs';

async function createDirectory(di