Node.js et le module fs : Lire et écrire des fichiers

Lorsque l’on débute avec Node.js, on découvre vite à quel point cet environnement peut être puissant pour créer des outils, des sites web, des scripts d’automatisation ou même de petites applications du quotidien. Pourtant, un élément essentiel finit toujours par revenir sur la table : la gestion des fichiers. Lire un document texte, enregistrer des données, mettre à jour un fichier de configuration, créer un journal d’activité… toutes ces opérations s’appuient sur un même acteur incontournable : le module fs de Node.js.

• Comprendre comment manipuler facilement ses fichiers et dossiers avec Node.js pour automatiser des tâches du quotidien.
• Acquérir les bases solides permettant de créer, lire, modifier et structurer ses données sans se perdre dans la technique.
• Développer l’autonomie nécessaire pour construire ses propres outils et améliorer sa productivité grâce au module fs.

Vous allez voir que manipuler les fichiers en JavaScript côté serveur n’a rien de sorcier. Bien au contraire, c’est souvent un déclic qui ouvre la porte à une nouvelle manière de travailler. Je me souviens encore de la première fois où j’ai automatisé une tâche répétitive avec un script Node.js. J’avais l’impression d’avoir découvert un super-pouvoir discret mais terriblement efficace. Vous risquez peut-être de ressentir la même chose en avançant dans ce guide.

Ce que je vous propose ici, c’est un guide clair et accessible pour vous montrer chaque étape avec des exemples concrets. Vous pourrez tout reproduire sur votre ordinateur, même si vous débutez totalement en programmation. L’objectif est que, d’ici la fin de ce tutoriel, vous soyez capable de lire, créer, modifier et organiser des fichiers comme un vrai professionnel, sans jamais vous sentir perdu.

Pourquoi Node.js fonctionne différemment du JavaScript dans un navigateur

Avant de plonger dans le module fs, vous devez comprendre un point fondamental : Node.js n’a rien à voir avec le JavaScript que vous utilisez dans un navigateur. Dans un navigateur, votre script se limite à interagir avec la page web, les événements utilisateurs ou l’API du navigateur. Il n’a aucun accès direct aux fichiers de l’ordinateur, pour des raisons évidentes de sécurité.

Node.js, lui, s’exécute sur votre machine. Il peut accéder au disque dur, à Internet, communiquer avec des bases de données, lire un dossier, écrire un fichier… bref, se comporter comme n’importe quel autre programme. C’est ce pouvoir supplémentaire qui fait de Node.js un environnement particulièrement apprécié pour créer des outils et des serveurs.

Comprendre et installer Node.js.

Cependant, cela implique aussi une règle essentielle : la plupart des opérations se font de manière asynchrone.

Une petite explication sur l’asynchrone

Avec Node.js, beaucoup d’actions prennent du temps. Lire un fichier de plusieurs mégaoctets, par exemple, peut durer une ou deux secondes. Node.js préfère ne pas bloquer l’ensemble du programme pendant ce laps de temps. À la place, il continue d’exécuter les instructions suivantes et vous rendra le résultat quand il sera disponible.

C’est un peu comme si vous commandiez un café au comptoir. Vous n’attendez pas forcément planté devant la machine. Vous avez le temps de lire vos messages, de ranger votre veste, et le serveur vous appellera lorsque votre café sera prêt.

Comprendre l’asynchronisme avec Node.js.

Cette logique s’applique également au module fs, qui propose la plupart des opérations en version asynchrone.

Qu’est-ce que le module fs exactement ?

Le module fs, abréviation de file system, est la bibliothèque officielle de Node.js pour interagir avec les fichiers et les dossiers. Il vous permet de :

• lire un fichier
• écrire un fichier
• vérifier si un fichier existe
• supprimer un fichier
• créer un dossier
• parcourir un dossier
• modifier un fichier existant
• et beaucoup d’autres choses encore.

Il est déjà inclus dans Node.js, vous n’avez donc rien à installer.

Par curiosité, découvrez NPM, pour installer des packages Node.js.

Comment l’utiliser dans votre code ?

Pour utiliser le module fs, il suffit de l’importer au début de votre script. Vous avez deux possibilités selon la manière dont vous écrivez votre code.

Méthode CommonJS (la plus courante en Node.js)

const fs = require('fs');

Méthode ES Modules (si votre projet utilise import/export)

import fs from 'fs';

Dans la majorité des cas, notamment si vous débutez, vous utiliserez encore la première solution.

Lire un fichier texte de manière simple

Commençons par quelque chose de simple et direct : ouvrir un fichier texte et en afficher le contenu. Pour cela, nous allons utiliser la méthode asynchrone fs.readFile.

Voici un exemple concret :

const fs = require('fs');

fs.readFile('example.txt', 'utf8', (error, data) => {
    if (error) {
        console.error('Une erreur est survenue :', error);
        return;
    }

    console.log('Contenu du fichier :');
    console.log(data);
});

Passons en revue ce qui se passe :

• Vous demandez au module fs de lire le fichier example.txt.
• Vous précisez l’encodage utf8 pour que Node.js vous renvoie directement du texte lisible.
• Enfin, vous lui transmettez une fonction callback appelée lorsque la lecture est terminée.

Dans la plupart des cas, vous devrez toujours vérifier si error contient quelque chose. Si c’est le cas, cela signifie que Node.js n’a pas réussi à ouvrir le fichier. Cela peut arriver si :

• le fichier n’existe pas
• vous n’avez pas les permissions
• son chemin est incorrect

Si tout se passe bien, la variable data contient alors le texte du fichier.

Vous pouvez tester cela très simplement en créant un fichier example.txt contenant quelques lignes, puis en lançant votre script avec la commande :

node votre_script.js

Lire un fichier sans callback : la version Promise

Node.js a évolué, et beaucoup de développeurs préfèrent utiliser async/await plutôt que des callbacks. Cela donne un code plus lisible et plus proche du fonctionnement habituel des langages modernes.

Voici l’équivalent en version Promise :

const fs = require('fs').promises;

async function lireFichier() {
    try {
        const contenu = await fs.readFile('example.txt', 'utf8');
        console.log(contenu);
    } catch (e) {
        console.error('Erreur lors de la lecture :', e);
    }
}

lireFichier();

Comparé à la version précédente, ici tout est plus fluide. Vous n’avez plus une fonction imbriquée en paramètre. À la place, vous utilisez await, qui suspend momentanément la fonction le temps de récupérer le résultat. C’est souvent ce que choisissent les projets professionnels.

Pour aller plus loin, Async/Await VS Promise

Écrire un fichier texte

Lire des fichiers, c’est bien, mais écrire dans un fichier, c’est un autre niveau de liberté. Avec fs.writeFile, vous pouvez créer un nouveau fichier ou remplacer complètement le contenu d’un fichier existant.

Voici un exemple :

const fs = require('fs');

fs.writeFile('nouveau.txt', 'Bonjour, ceci est un test.', 'utf8', (err) => {
    if (err) {
        console.error('Impossible d’écrire dans le fichier', err);
        return;
    }

    console.log('Fichier créé ou mis à jour avec succès.');
});

Vous passez un nom de fichier, du texte, un encodage, puis une fonction callback. Si le fichier n’existait pas, Node.js le crée pour vous. S’il existait, son contenu précédent disparaît pour laisser place au nouveau texte.

Je garde un souvenir très précis d’un moment où j’avais un script qui générait des rapports journaliers automatiquement. Chaque nuit, Node.js écrivait un fichier .txt avec les informations du jour. À l’époque, je trouvais cela presque magique. Ce genre de petit automatisme peut réellement vous simplifier la vie.

Version Promise avec async/await

De nouveau, voici la même opération en version moderne :

const fs = require('fs').promises;

async function ecrire() {
    try {
        await fs.writeFile('journal.txt', 'Entrée du jour : tout va bien.');
        console.log('Fichier écrit avec succès.');
    } catch (e) {
        console.error('Erreur lors de l’écriture :', e);
    }
}

ecrire();

La syntaxe est plus propre, surtout si vous enchaînez plusieurs opérations (créer un dossier, écrire un fichier, puis en modifier un autre).

Ajouter du contenu à un fichier existant – Utiliser fs.appendFile

Parfois, vous ne souhaitez pas remplacer le contenu d’un fichier mais y ajouter quelque chose à la fin. C’est le rôle de appendFile.

Par exemple, imaginons un fichier journal.log dans lequel vous accumulez des lignes d’activité :

const fs = require('fs');

fs.appendFile('journal.log', 'Nouvelle entrée à ' + new Date().toISOString() + '\n', (err) => {
    if (err) {
        console.error('Erreur lors de l’ajout :', err);
        return;
    }

    console.log('Ligne ajoutée avec succès.');
});

Cette méthode crée le fichier s’il n’existe pas encore. Elle est donc idéale pour stocker des logs, suivre des actions utilisateur ou garder en mémoire l’évolution d’un script.

Créer un dossier simplement

Maintenant que vous savez lire et écrire des fichiers, vous allez sans doute vouloir organiser tout cela dans des répertoires. C’est là qu’intervient la méthode fs.mkdir. Elle vous permet de créer un dossier n’importe où dans votre projet, du moment que vous avez les permissions nécessaires.

Voici un exemple classique :

const fs = require('fs');

fs.mkdir('donnees', (err) => {
    if (err) {
        console.error('Impossible de créer le dossier :', err);
        return;
    }

    console.log('Dossier créé avec succès.');
});

Si vous lancez ce code et que le dossier existe déjà, Node.js vous renverra une erreur. Pour éviter cela, vous pouvez ajouter une option très pratique.

Créer un dossier sans erreur s’il existe déjà

La version moderne de fs.mkdir (en utilisant les Promises) accepte une option appelée recursive. Cette option indique à Node.js de créer toutes les sous-arborescences nécessaires sans se plaindre si un dossier est déjà présent.

Voici comment faire :

const fs = require('fs').promises;

async function creerDossier() {
    try {
        await fs.mkdir('donnees/rapports/2025', { recursive: true });
        console.log('Arborescence créée ou déjà existante.');
    } catch (e) {
        console.error('Erreur :', e);
    }
}

creerDossier();

Cette option vous permet de travailler sereinement dans un projet où les dossiers se génèrent automatiquement selon les besoins. C’est très utile pour les outils d’automatisation, les scripts de sauvegarde ou les applications qui exportent des fichiers.

Lire le contenu d’un dossier

Une fois un répertoire créé, vous aurez certainement besoin d’en lire le contenu. Peut-être pour afficher la liste de fichiers, analyser des données, effectuer des traitements en chaîne, ou tout simplement vérifier ce qui s’y trouve. Pour cela, on utilise fs.readdir.

Voici un exemple simple :

const fs = require('fs');

fs.readdir('./donnees', (err, fichiers) => {
    if (err) {
        console.error('Erreur lors de la lecture du dossier :', err);
        return;
    }

    console.log('Liste des fichiers :');
    console.log(fichiers);
});

Dans cette version, fichiers est un tableau contenant les noms de tous les éléments présents dans le répertoire. Il peut s’agir de fichiers comme de dossiers.

Identifier si c’est un fichier ou un dossier

Si vous souhaitez distinguer les fichiers des dossiers, vous devrez utiliser fs.stat ou fs.lstat.

Par exemple :

const fs = require('fs');

fs.readdir('./donnees', (err, items) => {
    if (err) {
        console.error(err);
        return;
    }

    items.forEach((nom) => {
        fs.stat(`./donnees/${nom}`, (err, stats) => {
            if (err) return;

            if (stats.isFile()) {
                console.log(nom + ' est un fichier');
            }

            if (stats.isDirectory()) {
                console.log(nom + ' est un dossier');
            }
        });
    });
});

C’est un schéma très courant lorsque vous développez des outils internes ou des scripts d’analyse: Faire le tri dans des milliers de fichiers générés par erreur par un script mal configuré. Sans cette fonction, vous pourriez passer votre après-midi à cliquer comme un automate. Node.js va littéralement vous sauver la journée.

Supprimer un fichier avec fs.unlink

Quand vous travaillez avec le système de fichiers, il arrive forcément un moment où vous devez supprimer quelque chose. Node.js vous propose fs.unlink pour effacer un fichier.

Voici comment procéder :

const fs = require('fs');

fs.unlink('ancien.txt', (err) => {
    if (err) {
        console.error('Impossible de supprimer le fichier :', err);
        return;
    }

    console.log('Fichier supprimé avec succès.');
});

Si le fichier n’existe pas, une erreur est renvoyée. Vous pouvez donc vérifier avant de lancer l’opération en utilisant fs.access (que nous verrons un peu plus loin).

Supprimer un dossier avec fs.rmdir

La méthode classique pour supprimer un dossier est fs.rmdir. Cependant, elle ne peut effacer que des dossiers vides. Si votre répertoire contient des fichiers, vous devrez d’abord les supprimer un par un.

Exemple pour supprimer un dossier vide

const fs = require('fs');

fs.rmdir('donnees', (err) => {
    if (err) {
        console.error('Impossible de supprimer le dossier :', err);
        return;
    }

    console.log('Dossier supprimé.');
});

Supprimer un dossier entier, même s’il contient des fichiers

Dans les versions modernes de Node.js, vous pouvez utiliser fs.rm avec l’option recursive, ce qui simplifie énormément la vie.

const fs = require('fs').promises;

async function supprimerDossier() {
    try {
        await fs.rm('donnees', { recursive: true, force: true });
        console.log('Dossier supprimé entièrement.');
    } catch (e) {
        console.error('Erreur :', e);
    }
}

supprimerDossier();

L’option force permet d’éviter une erreur si le dossier n’existe pas, ce qui rend cette méthode très robuste dans des scripts d’automatisation.

Vérifier l’existence d’un fichier ou d’un dossier

Il est souvent utile de vérifier si un fichier existe avant de le lire, de l’écrire ou de le supprimer. Pour cela, fs.access est la méthode standard.

const fs = require('fs');

fs.access('example.txt', (err) => {
    if (err) {
        console.log('Le fichier n’existe pas.');
    } else {
        console.log('Le fichier existe.');
    }
});

Cette méthode peut aussi servir à vérifier les permissions, comme l’autorisation d’écrire ou de lire un fichier.

Vérifier les permissions de lecture

const fs = require('fs');

fs.access('example.txt', fs.constants.R_OK, (err) => {
    if (err) {
        console.log('Vous ne pouvez pas lire ce fichier.');
    } else {
        console.log('Lecture autorisée.');
    }
});

Vérifier les permissions d’écriture

const fs = require('fs');

fs.access('example.txt', fs.constants.W_OK, (err) => {
    if (err) {
        console.log('Vous ne pouvez pas écrire dans ce fichier.');
    } else {
        console.log('Écriture autorisée.');
    }
});

C’est une sécurité essentielle dans les projets professionnels où une mauvaise manipulation peut provoquer la perte de données ou un dysfonctionnement.

Lire et écrire des fichiers volumineux avec les Streams

Pourquoi utiliser les streams ? Jusqu’ici, toutes les méthodes que nous avons utilisées chargent entièrement un fichier en mémoire avant de l’exploiter. Cela fonctionne très bien pour des fichiers légers, mais devient problématique pour des fichiers lourds comme des vidéos, des archives ou de grandes bases de données texte.

C’est là que les streams entrent en scène !

Un stream, ou flux de données, fonctionne par petits morceaux. Au lieu de charger 300 Mo d’un coup, Node.js lit successivement des fragments du fichier. Cela économise de la mémoire et permet de traiter des fichiers gigantesques sans bloquer votre serveur.

C’est un peu comme regarder un film en streaming. Vous ne téléchargez pas les deux heures en entier avant de commencer à regarder. Une petite portion suffit, et le reste arrive au fur et à mesure.

Lire un fichier avec createReadStream

Voici un exemple très simple :

const fs = require('fs');

const flux = fs.createReadStream('video.mp4');

flux.on('data', (chunk) => {
    console.log('Nouveau morceau reçu :', chunk.length);
});

flux.on('end', () => {
    console.log('Lecture terminée.');
});

flux.on('error', (err) => {
    console.error('Erreur :', err);
});

À chaque fois qu’un fragment du fichier est disponible, l’événement data est déclenché. C’est extrêmement efficace pour analyser, traiter ou transférer des données.

Écrire un fichier avec createWriteStream

De la même manière, vous pouvez créer un flux d’écriture :

const fs = require('fs');

const flux = fs.createWriteStream('output.txt');

flux.write('Première ligne\n');
flux.write('Deuxième ligne\n');

flux.end(() => {
    console.log('Écriture terminée.');
});

Vous pouvez même combiner lecture et écriture pour copier un fichier.

Copier un fichier avec un pipe

Voici la méthode la plus simple au monde :

const fs = require('fs');

const lecture = fs.createReadStream('source.mp4');
const ecriture = fs.createWriteStream('copie.mp4');

lecture.pipe(ecriture);

Le pipe transfère automatiquement tous les fragments du flux de lecture vers celui d’écriture. Dans les serveurs Node.js, c’est la technique la plus utilisée pour envoyer un fichier au client sans surcharger la mémoire.

Des formations informatique pour tous !

Débutant ou curieux ? Apprenez le développement web, le référencement, le webmarketing, la bureautique, à maîtriser vos appareils Apple et bien plus encore…

Formateur indépendant, professionnel du web depuis 2006, je vous accompagne pas à pas et en cours particulier, que vous soyez débutant ou que vous souhaitiez progresser. En visio, à votre rythme, et toujours avec pédagogie.

Découvrez mes formations Qui suis-je ?

Manipuler et modifier des fichiers existants

Renommer un fichier avec fs.rename

Renommer un fichier est une opération très courante, surtout si vous générez automatiquement plusieurs versions d’un même document. Imaginons par exemple que vous exportiez des rapports journaliers et que vous souhaitiez renommer votre fichier rapport.txt en rapport-2025-01-01.txt.

Avec Node.js, cette opération est extrêmement simple :

const fs = require('fs');

fs.rename('rapport.txt', 'rapport-2025-01-01.txt', (err) => {
    if (err) {
        console.error('Erreur lors du renommage :', err);
        return;
    }

    console.log('Fichier renommé avec succès.');
});

Si le fichier d’origine n’existe pas ou si le chemin d’arrivée est invalide, une erreur sera renvoyée. En environnement professionnel, il est donc courant de vérifier d’abord l’existence du fichier avec fs.access.

Déplacer un fichier

Il n’existe pas de fonction fs.move à proprement parler, mais renommer un fichier en indiquant un chemin différent revient exactement au même.

Par exemple, pour déplacer un fichier dans un autre dossier :

fs.rename('rapport.txt', 'archives/rapport.txt', (err) => {
    if (err) {
        console.error('Déplacement impossible :', err);
        return;
    }

    console.log('Fichier déplacé.');
});

Cette technique fonctionne même si le dossier de destination se trouve à plusieurs niveaux de profondeur, à condition qu’il existe déjà.

Modifier un fichier : lire, transformer, réécrire

Pour modifier du contenu textuel, il n’existe pas de commande magique qui changerait une phrase directement dans un fichier. Il faut procéder en trois étapes :

• Lire le fichier
• Modifier son contenu en mémoire
• Réécrire le fichier

Voici un exemple typique :

const fs = require('fs').promises;

async function modifier() {
    try {
        let contenu = await fs.readFile('todo.txt', 'utf8');

        contenu = contenu.replace('course', 'courses');

        await fs.writeFile('todo.txt', contenu, 'utf8');

        console.log('Modification effectuée.');
    } catch (e) {
        console.error('Erreur :', e);
    }
}

modifier();

Ce schéma est utile pour tout ce qui concerne les fichiers de configuration, les listes à traiter ou les templates.

Comprendre les erreurs fréquentes avec fs

L’erreur “ENOENT”

C’est l’erreur que vous allez croiser le plus souvent. Elle signifie simplement que Node.js n’a pas trouvé le fichier ou le dossier demandé. Cela arrive lorsque vous :

• utilisez un chemin incorrect,
• ou tentez de lire un fichier qui n’existe pas encore.

Erreur : [Error: ENOENT: no such file or directory, open 'test.txt']

Dans la majorité des cas, il suffit de vérifier votre chemin relatif. Petit rappel important : Avec Node.js, les chemins sont relatifs au script exécuté, pas à votre terminal.

L’erreur “EACCES”

Cette erreur apparaît lorsque vous essayez de lire ou d’écrire un fichier sans en avoir la permission. Cela arrive parfois sur les serveurs Linux, notamment dans les répertoires système. Pour la contourner, vous pouvez :

• changer les permissions du fichier,
• ou exécuter votre script avec les droits nécessaires.

En savoir plus sur Les permissions avec CHMOD.

Les erreurs de verrouillage de fichier

Certaines plateformes, notamment Windows, peuvent verrouiller un fichier lorsqu’il est utilisé par un autre programme. Par exemple, un fichier ouvert dans un éditeur peut provoquer une erreur lors de l’écriture.

Dans la plupart des cas, redémarrer votre éditeur ou fermer la fenêtre suffit.

C’est d’ailleurs une erreur classique chez les développeurs débutants : passer vingt minutes à chercher pourquoi un script ne peut pas supprimer un fichier, pour finalement découvrir que le document est encore ouvert dans un autre logiciel. Cela arrive à tout le monde et vous n’y échapperez probablement pas un jour.

Utiliser fs de manière professionnelle : les bonnes pratiques

Toujours vérifier l’existence d’un fichier avant de le manipuler

Même si certaines méthodes comme fs.rm acceptent l’option force, il est souvent recommandé de vérifier l’existence d’un fichier avant de l’ouvrir, surtout dans un contexte sensible.

const fs = require('fs');

fs.access('config.json', fs.constants.R_OK, (err) => {
    if (err) {
        console.log('Le fichier config.json est introuvable ou illisible.');
    } else {
        console.log('Le fichier existe, nous pouvons continuer.');
    }
});

Cette étape prévient les erreurs inattendues.

Utiliser les Promises lorsque c’est possible

Même si les callbacks fonctionnent très bien, l’utilisation des Promises rend votre code plus clair, notamment lorsque vous enchaînez plusieurs opérations.

Regardez la différence entre ceci :

fs.readFile(..., (err, data) => {
    fs.writeFile(..., (err) => {
        fs.appendFile(..., (err) => {
            console.log('Terminé');
        });
    });
});

Et ceci :

await fs.readFile(...);
await fs.writeFile(...);
await fs.appendFile(...);

Le second est plus lisible, facile à maintenir et moins sujet aux erreurs. Dans des projets évolutifs, cette approche fait une vraie différence.

Éviter les chemins relatifs trop complexes

Une erreur courante consiste à faire référence à un fichier en supposant que Node.js connaît son emplacement exact. Ce n’est pas toujours le cas. Utilisez plutôt __dirname pour créer des chemins robustes. Par exemple :

const path = require('path');
const fs = require('fs').promises;

async function lire() {
    const chemin = path.join(__dirname, 'donnees', 'info.txt');
    const contenu = await fs.readFile(chemin, 'utf8');
    console.log(contenu);
}

lire();

Cela évite les grosses surprises lorsqu’un script est lancé depuis un autre dossier.

Organiser vos fichiers dans des répertoires logiques

Avec Node.js, vous allez rapidement accumuler des fichiers générés automatiquement. Il est donc conseillé de les classer dans des dossiers clairs comme :

• logs
• exports
• archives
• tmp
• rapports
• config
• donnees

Ce n’est pas une règle obligatoire, mais cela vous évitera de transformer votre projet en labyrinthe.

Apprenez à Bien structurer vos projets Node.js.

Travailler avec le JSON : un cas très courant en Node.js

Node.js et JSON entretiennent une relation particulière. JSON est un format très proche du JavaScript, donc il est naturel de l’utiliser pour stocker des configurations, des données, des préférences ou des historiques.

Lire un fichier JSON

const fs = require('fs').promises;

async function lireJSON() {
    try {
        const texte = await fs.readFile('config.json', 'utf8');
        const donnees = JSON.parse(texte);
        console.log(donnees);
    } catch (e) {
        console.error('Erreur JSON :', e);
    }
}

lireJSON();

Vous lisez un fichier texte, puis vous utilisez JSON.parse pour le transformer en véritable objet JavaScript.

Écrire un fichier JSON

Pour écrire un fichier JSON sans perdre la lisibilité, utilisez JSON.stringify.

const fs = require('fs').promises;

async function ecrireJSON() {
    const settings = {
        theme: 'clair',
        langue: 'fr',
        version: 2
    };

    try {
        await fs.writeFile('config.json', JSON.stringify(settings, null, 4));
        console.log('JSON écrit avec succès.');
    } catch (e) {
        console.error('Erreur :', e);
    }
}

ecrireJSON();

L’argument null, 4 permet d’indenter le JSON sur 4 espaces pour le rendre lisible à l’œil humain.

Cas pratiques : utiliser fs et Node.js dans des situations réelles

Après avoir exploré les fonctionnalités essentielles du module fs, il est temps de passer aux cas concrets. Rien ne vaut un véritable scénario pour comprendre l’utilité de ce que vous apprenez. Ces exemples sont inspirés de situations vécues en freelance ou dans des projets personnels. Ils ont le mérite d’être simples, réalistes et facilement réutilisables.

Créer un script qui génère un rapport tous les jours

Imaginons que vous souhaitiez créer un petit outil pour enregistrer automatiquement un journal quotidien. Cela peut servir dans un projet professionnel, mais aussi dans un cadre personnel pour garder une trace de votre activité.

const fs = require('fs').promises;
const path = require('path');

async function genererRapport() {
    const dossier = path.join(__dirname, 'rapports');
    await fs.mkdir(dossier, { recursive: true });

    const dateActuelle = new Date().toISOString().slice(0, 10);
    const cheminFichier = path.join(dossier, `${dateActuelle}.txt`);

    const contenu = `Rapport du ${dateActuelle}\nTout s'est bien passé aujourd’hui.\n`;

    await fs.writeFile(cheminFichier, contenu);
    console.log('Rapport généré :', cheminFichier);
}

genererRapport();

Ce petit script pourrait être exécuté automatiquement chaque jour à l’aide d’un cron (sur Linux ou MacOS) ou d’un planificateur de tâches (sur Windows). Vous obtenez alors une archive propre, structurée, et facile à relire.

Construire un outil de sauvegarde rapide

Un autre usage fréquent du module fs consiste à créer des sauvegardes automatiques de certains fichiers importants. C’est le genre d’outil qui peut sauver un projet, surtout en freelance lorsqu’un client vous demande une restauration que vous n’aviez pas anticipée.

Voici une version simplifiée :

const fs = require('fs');
const path = require('path');

function sauvegarder(source, destination) {
    const lecture = fs.createReadStream(source);
    const ecriture = fs.createWriteStream(destination);

    lecture.pipe(ecriture);

    lecture.on('end', () => {
        console.log('Sauvegarde terminée.');
    });

    lecture.on('error', (err) => {
        console.error('Erreur lors de la sauvegarde :', err);
    });
}

const date = new Date().toISOString().replace(/:/g, '-');
sauvegarder('config.json', `backup/config-${date}.json`);

Ce type de script fonctionne pour n’importe quel fichier : base de données SQLite, configuration, images, etc. Grâce aux streams, vous pouvez même sauvegarder de très gros fichiers sans saturer la mémoire.

Apprenez à vous Connecter à une base de données avec Node.js.

Générer un fichier HTML automatiquement

Travailler avec fs permet aussi de générer des fichiers HTML, par exemple pour créer des pages statiques, des rapports graphiques ou des exports visuels.

Voici une petite démonstration :

const fs = require('fs').promises;

async function genererHTML() {
    const contenu = `
<!DOCTYPE html>
<html lang="fr">
<head>
    <meta charset="UTF-8">
    <title>Rapport automatisé</title>
</head>
<body>
    <h1>Rapport généré automatiquement</h1>
    <p>Date : ${new Date().toLocaleString()}</p>
</body>
</html>
`;

    await fs.writeFile('rapport.html', contenu, 'utf8');
    console.log('Page HTML créée.');
}

genererHTML();

C’est une manière simple, élégante et rapide d’automatiser des tâches qui demanderaient sinon de manipuler un éditeur à la main.

Créer une mini-base de données locale en JSON

Beaucoup de débutants utilisent une base de données SQL trop tôt, alors qu’une simple structure JSON peut suffire au départ. Grâce au module fs, vous pouvez créer une sorte de “mini-base” sous forme de fichier.

Voici un exemple concret :

const fs = require('fs').promises;

async function ajouterUtilisateur(nom) {
    try {
        let data = [];

        try {
            const texte = await fs.readFile('utilisateurs.json', 'utf8');
            data = JSON.parse(texte);
        } catch {}

        data.push({
            nom,
            dateInscription: new Date().toISOString()
        });

        await fs.writeFile('utilisateurs.json', JSON.stringify(data, null, 4));
        console.log('Utilisateur ajouté :', nom);
    } catch (e) {
        console.error(e);
    }
}

ajouterUtilisateur('Alban');

Cette technique est parfaite pour :

• garder un historique,
• noter des événements,
• tester une API,
• ou créer un prototype.

Beaucoup de développeurs professionnels continuent d’utiliser ce genre d’astuce pour les tests rapides.

Astuces utiles pour mieux travailler avec fs

Toujours utiliser path.join pour créer des chemins propres

Node.js fonctionne sur Windows, Mac et Linux. Chacun a ses propres séparateurs de chemin. Par exemple :

• Windows : dossier\images
• Linux/Mac : dossier/images

Pour éviter toute incompatibilité, utilisez systématiquement :

const path = require('path');
const fichier = path.join(__dirname, 'dossier', 'fichier.txt');

Cela vous évite des heures de débogage, en particulier si vous partagez votre code avec d’autres personnes.

Préparer vos scripts aux erreurs inattendues

La majorité des erreurs avec fs tourne autour de trois causes :

• un fichier n’existe pas,
• un fichier n’est pas accessible,
• une opération est bloquée par un autre programme.

Pour éviter les dysfonctionnements, placez toujours vos opérations dans un try/catch si vous utilisez async/await.

async function lire() {
    try {
        const data = await fs.readFile('notes.txt', 'utf8');
        console.log(data);
    } catch (e) {
        console.error('Impossible de lire le fichier :', e.message);
    }
}

C’est une habitude professionnelle très appréciée.

Éviter d’écrire trop fréquemment dans un fichier

Node.js peut écrire dans des fichiers à grande vitesse, mais une écriture trop fréquente (par exemple plusieurs fois par seconde) peut user le disque ou provoquer des conflits. Dans certains cas, il vaut mieux regrouper les écritures.

Une technique courante consiste à accumuler les lignes dans une variable, puis à écrire le tout, toutes les X secondes. Cela limite les risques tout en améliorant les performances.

Utiliser fs dans un serveur Node.js

Servir un fichier HTML avec fs

Lorsque vous développez un serveur Node.js sans framework, vous utiliserez souvent fs pour renvoyer des fichiers au navigateur.

Voici un petit serveur minimaliste :

const http = require('http');
const fs = require('fs').promises;

const serveur = http.createServer(async (req, res) => {
    try {
        const page = await fs.readFile('index.html');
        res.writeHead(200, { 'Content-Type': 'text/html' });
        res.end(page);
    } catch {
        res.writeHead(500);
        res.end('Erreur interne');
    }
});

serveur.listen(3000, () => {
    console.log('Serveur lancé sur https://localhost:3000');
});

Ce type d’exemple montre à quel point fs est souvent au cœur des applications Node.js. Même derrière des frameworks comme Express, il reste omniprésent, sans que vous ne le voyiez forcément.

Servir une image, un PDF ou un fichier volumineux

Pour les gros fichiers, il est vivement conseillé d’utiliser les streams :

const http = require('http');
const fs = require('fs');

http.createServer((req, res) => {
    const flux = fs.createReadStream('video.mp4');

    res.writeHead(200, { 'Content-Type': 'video/mp4' });
    flux.pipe(res);

    flux.on('error', () => {
        res.writeHead(404);
        res.end('Fichier introuvable');
    });
}).listen(3000);

Cette technique est très utilisée dans les serveurs de streaming ou de téléchargement.

Nous avons maintenant exploré la quasi-totalité des fonctionnalités essentielles et avancées du module fs en Node.js. Vous savez lire, écrire, supprimer, déplacer, modifier et analyser des fichiers. Vous savez travailler avec les flux, créer des archives, manipuler des répertoires, et utiliser JSON comme base de données locale.

Lorsque l’on prend un moment pour regarder en arrière, il est assez fascinant de constater tout ce que l’on peut accomplir avec Node.js et son module fs. Un simple script devient un petit outil. Un petit outil se transforme en automatisation. Puis, sans même s’en rendre compte, on finit par créer un véritable environnement de travail capable de lire, écrire, classer, analyser et organiser des fichiers comme si tout cela n’était qu’un jeu d’enfant. Pourtant, rien n’est magique dans ce que vous avez découvert ici. C’est la logique de Node.js, la puissance du système de fichiers, et surtout votre compréhension pas à pas qui vous permettent aujourd’hui d’être autonome.

L’essentiel, finalement, ce n’est pas seulement de connaître les méthodes fs.readFile ou fs.writeFile, ni même de savoir manipuler les streams ou renommer un fichier. Ce qui compte vraiment, c’est de sentir que vous avez acquis une nouvelle manière de dialoguer avec votre machine. Vous êtes passé d’un JavaScript enfermé dans un navigateur à un JavaScript capable de toucher à votre disque dur, d’automatiser vos tâches, de créer des archives, d’alimenter un serveur ou d’inventer vos propres outils. C’est un changement silencieux, presque intime, mais qui ouvre un champ immense de possibilités. Beaucoup de développeurs vous le diront : c’est souvent ce moment précis qui fait naître la passion pour Node.js.

Si vous prenez le temps d’expérimenter un peu, vous verrez que les idées viennent très vite. Un export automatique par-ci, une sauvegarde quotidienne par-là, une page HTML générée à la volée, un script pour renommer vos photos, ou même un mini-serveur personnel. La seule limite, désormais, sera votre imagination et votre curiosité. Alors continuez d’explorer, d’essayer, de modifier, de casser et de réparer. Ce sont ces petites tentatives parfois maladroites qui façonnent le véritable apprentissage. Node.js est un formidable terrain de jeu pour progresser sans pression, et fs en est l’un des outils les plus accessibles et les plus gratifiants.

Si ce chapitre vous a accompagné dans vos premiers pas, alors il a déjà rempli son rôle. Et si, en plus, il vous a donné l’envie d’aller plus loin, c’est encore mieux. À présent, vous avez tout en main pour construire vos propres scripts, vos propres services, et vos propres outils. Prenez plaisir à créer, à explorer, à manipuler vos fichiers comme bon vous semble. La suite de votre aventure avec Node.js ne dépend plus que d’une chose : votre envie d’oser. Et vous verrez, elle vous mènera très loin.

Alban

Fondateur de l’agence Créa-troyes.
Intervenant en Freelance.
Contactez-moi

crea-troyes.fr