Avez-vous une question? (216) 97 656 803 hajjriadh@gmail.com
Laravel

Les modules natifs de Node.js : fs, path, os, url et events

Cette leçon présente les modules natifs livrés avec Node.js et leur import avec le préfixe node:. Elle détaille le module fs/promises (lire, écrire, ajouter, lister, créer et supprimer des fichiers et...

0 chapitres 0 QCM Accès gratuit
Dans cet article

À propos de ce cours

Cette leçon présente les modules natifs livrés avec Node.js et leur import avec le préfixe node:. Elle détaille le module fs/promises (lire, écrire, ajouter, lister, créer et supprimer des fichiers et dossiers, gérer les erreurs comme ENOENT), le module path pour construire des chemins valables sous Windows comme sous Linux, le module os pour les informations sur le système, la classe URL pour analyser une adresse et ses paramètres, et EventEmitter du module events pour programmer avec des événements (on, once, emit). Tous les exemples ont été exécutés ; deux activités corrigées (inventaire d'un dossier, journal des commandes) et un quiz complètent la leçon.
  1. Objectifs

    • Savoir ce que sont les modules natifs de Node.js et comment les importer.
    • Lire, écrire et lister des fichiers avec node:fs/promises, et gérer les erreurs de fichiers.
    • Construire des chemins fiables avec node:path.
    • Obtenir des informations sur le système avec node:os, analyser une adresse avec URL et programmer avec des événements grâce à node:events.
  2. Présentation des modules natifs

    • Les modules natifs (core modules) sont livrés avec Node.js : rien à installer, rien à ajouter dans package.json. Ils donnent accès à ce que le navigateur interdit : fichiers, réseau, processus, système d'exploitation.
    • On les importe avec le préfixe node:, qui évite toute confusion avec un paquet npm du même nom :
    import fs from 'node:fs/promises';      // module ES
    const path = require('node:path');      // CommonJS
    ModuleRôleVoir
    node:fsFichiers et dossiersCette leçon
    node:pathChemins de fichiersCette leçon
    node:osInformations sur le systèmeCette leçon
    node:url et URLAdresses webCette leçon
    node:eventsÉmettre et écouter des événementsCette leçon
    node:httpCréer un serveur webChapitre 6
    node:cryptoHachage, chiffrement, identifiants aléatoiresChapitre sur l'authentification
    node:readline, node:child_process, node:util, node:testLecture au clavier, lancement de programmes, utilitaires, testsDocumentation de Node.js
  3. Le module fs : fichiers et dossiers

    1. Trois styles d'API
      • Le module fs (file system) existe en trois versions :
        • node:fs/promises: les fonctions renvoient des promesses, à utiliser avec await. C'est la version recommandée;
        • node:fs avec des callbacks: fs.readFile(fichier, (err, data) => …), l'ancien style que l'on rencontre dans le code existant ;
        • les versions synchrones : fs.readFileSync(). Elles bloquent Node.js pendant la lecture : acceptables dans un petit script, à éviter dans un serveur.
      • Le chapitre 5 explique en détail la différence entre synchrone et asynchrone.
    2. Lire, écrire et lister
      // fichiers.js : lire, écrire et lister des fichiers avec fs/promises
      import { mkdir, writeFile, appendFile, readFile, readdir, stat, rm } from 'node:fs/promises';
      import path from 'node:path';
      
      const dossier = path.join(import.meta.dirname, 'donnees');
      const fichier = path.join(dossier, 'journal.txt');
      
      await mkdir(dossier, { recursive: true });              // crée le dossier s'il n'existe pas
      await writeFile(fichier, 'Première ligne\n', 'utf8');   // crée ou remplace le fichier
      await appendFile(fichier, 'Deuxième ligne\n', 'utf8');  // ajoute à la fin
      
      const contenu = await readFile(fichier, 'utf8');
      console.log(contenu);
      
      const infos = await stat(fichier);
      console.log(`Taille : ${infos.size} octets, modifié le ${infos.mtime.toLocaleDateString('fr-FR')}`);
      console.log('Contenu du dossier :', await readdir(dossier));
      
      await rm(dossier, { recursive: true });                 // nettoyage
      node fichiers.js
      Première ligne
      Deuxième ligne
      
      Taille : 32 octets, modifié le 15/11/2026
      Contenu du dossier : [ 'journal.txt' ]
      FonctionRôle
      readFile(f, 'utf8')Lire tout le fichier sous forme de texte (sans 'utf8', on obtient un Buffer)
      writeFile(f, texte)Créer le fichier, ou remplacer son contenu
      appendFile(f, texte)Ajouter à la fin du fichier
      mkdir(d, { recursive: true })Créer un dossier et ses parents, sans erreur s'il existe
      readdir(d)Lister le contenu d'un dossier
      stat(f)Taille, dates, isFile(), isDirectory()
      rename(a, b), copyFile(a, b)Renommer (ou déplacer), copier
      rm(f, { recursive: true })Supprimer un fichier ou un dossier
    3. Gérer les erreurs
      • Une opération sur un fichier peut échouer : fichier absent, droits insuffisants… Avec await, on l'entoure d'un try...catch et on examine erreur.code:
      import { readFile } from 'node:fs/promises';
      
      try {
        const texte = await readFile('parametres.json', 'utf8');
        console.log(JSON.parse(texte));
      } catch (erreur) {
        if (erreur.code === 'ENOENT') {
          console.log('Fichier absent : utilisation des paramètres par défaut.');
        } else {
          throw erreur;   // autre problème : on ne le cache pas
        }
      }
    4. Les codes les plus courants : ENOENT (fichier ou dossier introuvable), EACCES ou EPERM (droits insuffisants), EEXIST (existe déjà), EISDIR (c'est un dossier).
  4. Le module path : des chemins fiables

    • Windows sépare les dossiers par \, Linux et macOS par /. Construire un chemin en collant des chaînes (dossier + '/' + fichier) donne un code qui casse d'un système à l'autre. Le module path s'en charge :
    // chemins.js : manipuler des chemins avec path
    import path from 'node:path';
    
    const chemin = path.join('projets', 'boutique', 'images', 'logo.png');
    console.log(chemin);                       // séparateur adapté au système
    console.log(path.basename(chemin));        // logo.png
    console.log(path.extname(chemin));         // .png
    console.log(path.dirname(chemin));         // projets/boutique/images
    console.log(path.parse(chemin));
    console.log(path.resolve('donnees.json')); // chemin absolu depuis le dossier courant
    node chemins.js
    projets\boutique\images\logo.png
    logo.png
    .png
    projets\boutique\images
    {
      root: '',
      dir: 'projets\\boutique\\images',
      base: 'logo.png',
      ext: '.png',
      name: 'logo'
    }
    C:\Projets\natifs\donnees.json
  5. Résultat sous Windows ; sous Linux, les mêmes lignes affichent projets/boutique/images/logo.png.
  6. path.resolve() part du dossier courant du terminal. Pour un fichier placé à côté du script, quel que soit l'endroit d'où on le lance, on part du dossier du module : path.join(import.meta.dirname, 'donnees.json') (ou __dirname en CommonJS).
  7. Le module os : informations sur le système

    // systeme.js : informations sur l'ordinateur avec os
    import os from 'node:os';
    
    console.log(`Système : ${os.platform()} ${os.release()} (${os.arch()})`);
    console.log(`Ordinateur : ${os.hostname()}, utilisateur : ${os.userInfo().username}`);
    console.log(`Processeurs : ${os.cpus().length}, mémoire : ${(os.totalmem() / 1024 ** 3).toFixed(1)} Go`);
    console.log(`Allumé depuis ${(os.uptime() / 3600).toFixed(1)} heures`);
    node systeme.js
    Système : win32 10.0.26100 (x64)
    Ordinateur : PC-RIADH, utilisateur : riadh
    Processeurs : 8, mémoire : 15.8 Go
    Allumé depuis 5.3 heures
  8. On s'en sert pour adapter un programme au système, ou pour un outil de diagnostic. os.homedir() donne le dossier personnel de l'utilisateur, os.tmpdir() le dossier temporaire et os.EOL le caractère de fin de ligne du système.
  9. URL : analyser une adresse web

    • La classe URL, globale comme dans le navigateur, découpe une adresse en parties. Elle servira à lire les paramètres des requêtes d'un serveur web :
    // adresses.js : analyser une adresse web avec URL
    const adresse = new URL('https://boutique.tn:8080/produits/recherche?q=clavier&page=2#avis');
    
    console.log(adresse.protocol);   // https:
    console.log(adresse.hostname);   // boutique.tn
    console.log(adresse.port);       // 8080
    console.log(adresse.pathname);   // /produits/recherche
    console.log(adresse.searchParams.get('q'));      // clavier
    console.log(Number(adresse.searchParams.get('page')) + 1);  // 3
    adresse.searchParams.set('page', '3');
    console.log(adresse.href);
    node adresses.js
    https:
    boutique.tn
    8080
    /produits/recherche
    clavier
    3
    https://boutique.tn:8080/produits/recherche?q=clavier&page=3#avis
  10. Les valeurs de searchParams sont toujours des chaînes: on les convertit avec Number() avant de calculer. Le module node:url fournit en plus fileURLToPath() et pathToFileURL(), pour passer d'une adresse file:/// à un chemin et inversement.
  11. Le module events : programmer avec des événements

    • Une grande partie de Node.js fonctionne par événements: un serveur émet request à chaque requête, un flux de fichier émet data puis end… La classe EventEmitter permet d'utiliser ce mécanisme dans son propre code :
      • on(nom, fonction) enregistre un écouteur, appelé à chaque émission ;
      • once(nom, fonction) enregistre un écouteur appelé une seule fois;
      • emit(nom, données) émet l'événement et appelle tous ses écouteurs, dans l'ordre d'enregistrement ;
      • off(nom, fonction) retire un écouteur.
    // evenements.js : émettre et écouter des événements avec EventEmitter
    import { EventEmitter } from 'node:events';
    
    class Commande extends EventEmitter {
      passer(produit, quantite) {
        console.log(`Commande de ${quantite} × ${produit}`);
        this.emit('commandee', { produit, quantite });
        if (quantite > 10) this.emit('grosse-commande', produit);
      }
    }
    
    const commande = new Commande();
    
    commande.on('commandee', (infos) => console.log(`  → e-mail de confirmation (${infos.produit})`));
    commande.on('commandee', () => console.log('  → stock mis à jour'));
    commande.once('grosse-commande', (p) => console.log(`  → alerte : grosse commande de ${p}`));
    
    commande.passer('clavier', 2);
    commande.passer('souris', 15);
    commande.passer('écran', 12);   // « once » : l'alerte ne se déclenche plus
    node evenements.js
    Commande de 2 × clavier
      → e-mail de confirmation (clavier)
      → stock mis à jour
    Commande de 15 × souris
      → e-mail de confirmation (souris)
      → stock mis à jour
      → alerte : grosse commande de souris
    Commande de 12 × écran
      → e-mail de confirmation (écran)
      → stock mis à jour
  12. L'intérêt : la classe Commande ne sait rien des e-mails ni du stock. On peut ajouter un nouveau traitement (une facture, une statistique) sans la modifier, simplement en ajoutant un écouteur.
  13. Activité 1 : inventaire d'un dossier

    • Écrivez inventaire.js (module ES), qui reçoit un nom de dossier en argument (node inventaire.js images) et affiche, pour chaque fichier du dossier, son nom, son extension et sa taille en Ko, puis la taille totale. Si le dossier n'existe pas, affichez « Dossier introuvable ».
    • Voir le corrigé
      // inventaire.js
      import { readdir, stat } from 'node:fs/promises';
      import path from 'node:path';
      
      const dossier = process.argv[2] ?? '.';
      let total = 0;
      
      try {
        for (const nom of await readdir(dossier)) {
          const infos = await stat(path.join(dossier, nom));
          if (!infos.isFile()) continue;          // on ignore les sous-dossiers
          total += infos.size;
          console.log(`${nom.padEnd(25)} ${path.extname(nom).padEnd(6)} ${(infos.size / 1024).toFixed(1)} Ko`);
        }
        console.log(`Total : ${(total / 1024).toFixed(1)} Ko`);
      } catch (erreur) {
        if (erreur.code === 'ENOENT') console.log('Dossier introuvable');
        else throw erreur;
      }
  14. Activité 2 : un journal des événements

    • Reprenez la classe Commande. Ajoutez un écouteur de l'événement commandee qui ajoute une ligne dans le fichier commandes.log, sous la forme 2026-11-15T10:24:03.120Z;clavier;2. Ajoutez ensuite un compteur des commandes qui s'affiche après la troisième commande.
    • Voir le corrigé
      import { appendFile } from 'node:fs/promises';
      
      commande.on('commandee', async ({ produit, quantite }) => {
        const ligne = `${new Date().toISOString()};${produit};${quantite}\n`;
        await appendFile(path.join(import.meta.dirname, 'commandes.log'), ligne, 'utf8');
      });
      
      let nombre = 0;
      commande.on('commandee', () => {
        nombre++;
        if (nombre === 3) console.log(`  → ${nombre} commandes enregistrées`);
      });

      N'oubliez pas import path from 'node:path';. Aucune ligne de la classe Commande n'a été modifiée : c'est tout l'intérêt des événements.

  15. À retenir

    • Les modules natifs sont fournis par Node.js ; on les importe avec le préfixe node:.
    • node:fs/promises avec await pour les fichiers ; try...catch et erreur.code (ENOENT…) pour les erreurs.
    • path.join() pour construire des chemins valables sur tous les systèmes ; import.meta.dirname pour partir du dossier du script.
    • os décrit le système, URL découpe une adresse, EventEmitter fait communiquer des parties du code par événements.
  16. Testez-vous

    • 1. Faut-il installer fs avec npm ?
    • 2. Quelle est la différence entre writeFile et appendFile?
    • 3. Pourquoi éviter dossier + '/' + fichier?
    • 4. Quelle est la différence entre on et once?
    • Voir les réponses
      1. Non : c'est un module natif, livré avec Node.js.
      2. writeFile remplace le contenu du fichier ; appendFile ajoute à la fin.
      3. Parce que le séparateur dépend du système ; path.join() utilise le bon et supprime les séparateurs en double.
      4. Un écouteur on est appelé à chaque émission ; un écouteur once seulement à la première.

Cet article vous a-t-il aidé ?