Travailler avec le système de fichiers en TypeScript pour débutants

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

Travailler avec le système de fichiers est l'une des tâches clés lors du développement en TypeScript. Que vous créiez une application serveur, un utilitaire de traitement de données ou un serveur web, vous aurez nécessairement besoin de lire, écrire et gérer des fichiers et des répertoires. Dans ce guide, nous aborderons les bases du travail avec le module fs (File System) en TypeScript, examinerons les opérations synchrones et asynchrones, et apprendrons à gérer les erreurs.

TypeScript est une surcouche fortement typée de JavaScript qui ajoute un typage statique. Lors du travail avec le système de fichiers, nous utiliserons le module standard Node.js fs, mais avec les avantages supplémentaires de TypeScript : l'autocomplétion, la vérification des types et une meilleure lisibilité du code.

Configuration du projet et importation des modules

Avant de commencer, assurez-vous d'avoir installé Node.js et TypeScript. Créez un nouveau projet et installez les types nécessaires :

mkdir fs-typescript-tutorialcd fs-typescript-tutorialnpm init -ynpm install typescript @types/node --save-devnpx tsc --init

Pour travailler avec le système de fichiers, nous aurons besoin de deux modules principaux :

• fs — pour effectuer des opérations sur les fichiers (lecture, écriture, suppression, etc.)
• path — pour travailler facilement avec les chemins (concaténation, normalisation, obtention de l'extension)

Importons-les dans notre fichier TypeScript :

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

// Variante alternative — importer uniquement les fonctions nécessaires :import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'fs';import { join, resolve } from 'path';

Notez que nous utilisons import * as fs, car le module fs exporte de nombreuses fonctions. TypeScript récupérera automatiquement les types du paquet @types/node installé.

Lecture et écriture de fichiers

Commençons par les opérations les plus basiques — la lecture et l'écriture de fichiers texte. Dans Node.js, il existe deux approches : synchrone et asynchrone. Pour les scripts et utilitaires simples, on utilise souvent les méthodes synchrones, et pour les serveurs à forte charge, les méthodes asynchrones, afin de ne pas bloquer la boucle d'événements.

Lecture et écriture synchrones

Les méthodes synchrones bloquent l'exécution du programme jusqu'à la fin de l'opération. Elles sont simples à utiliser et conviennent aux scénarios où la vitesse n'est pas critique :

import { readFileSync, writeFileSync } from 'fs';import { join } from 'path';

const filePath = join(__dirname, 'data.txt');

// Écriture dans un fichier (crée le fichier s'il n'existe pas)writeFileSync(filePath, 'Bonjour, TypeScript !', 'utf-8');

// Lecture d'un fichierconst content: string = readFileSync(filePath, 'utf-8');console.log(content); // Affichera : Bonjour, TypeScript !

Notez le typage content: string — TypeScript garantit que nous obtenons une chaîne de caractères. Si le fichier n'existe pas, une exception sera levée, qu'il faut gérer avec try/catch.

Lecture et écriture asynchrones

Les méthodes asynchrones acceptent un callback ou retournent une Promise (dans les versions modernes). Il est recommandé d'utiliser les versions Promise avec async/await :

import { promises as fsPromises } from 'fs';import { join } from 'path';

const filePath = join(__dirname, 'async-data.txt');

async function handleFile(): Promise<void> {    try {        // Écriture asynchrone        await fsPromises.writeFile(filePath, 'Contenu asynchrone', 'utf-8');                // Lecture asynchrone        const data: string = await fsPromises.readFile(filePath, 'utf-8');        console.log(data); // Contenu asynchrone    } catch (error) {        console.error('Erreur lors du travail avec le fichier :', error);    }}

handleFile();

L'utilisation de async/await rend le code similaire à du code synchrone