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

Les modules CommonJS : require et module.exports

Cette leçon explique ce qu'est un module et pourquoi découper une application en modules, puis présente CommonJS, le système historique de Node.js. On y apprend à exporter avec module.exports (plusieu...

0 chapitres 0 QCM Accès gratuit
Dans cet article

À propos de ce cours

Cette leçon explique ce qu'est un module et pourquoi découper une application en modules, puis présente CommonJS, le système historique de Node.js. On y apprend à exporter avec module.exports (plusieurs éléments ou une seule classe), à charger avec require() et la déstructuration, à lire un fichier JSON, et à distinguer vos fichiers, les modules natifs (préfixe node:) et les paquets npm. Le cache des modules, la fonction qui enveloppe chaque fichier (origine de __dirname et __filename) et le piège de la réaffectation de exports sont démontrés avec des exemples testés. Deux activités corrigées (module de validation, cache partagé) et un quiz complètent la leçon.
  1. Objectifs

    • Comprendre ce qu'est un module et pourquoi on découpe une application en modules.
    • Créer un module CommonJS avec module.exports et le charger avec require().
    • Connaître les trois sortes de modules : vos fichiers, les modules natifs et les paquets npm.
    • Comprendre le cache des modules et éviter le piège de exports.
  2. Qu'est-ce qu'un module ?

    • Un module est un fichier JavaScript qui regroupe du code sur un même sujet (calculs de prix, accès à la base, validation…) et qui choisit ce qu'il partage avec le reste de l'application.
    • Découper une application en modules permet :
      • de garder des fichiers courts et lisibles ;
      • de réutiliser le même code dans plusieurs fichiers ou projets ;
      • d'isoler les variables : ce qui n'est pas exporté reste privé au fichier, sans risque de conflit de noms ;
      • de tester chaque partie séparément.
    • Node.js connaît deux systèmes de modules :
      • CommonJS (require / module.exports) : le système historique de Node.js, présent dans un très grand nombre de projets et de paquets existants. C'est l'objet de cette leçon ;
      • les modules ES (import / export) : le standard du langage JavaScript, recommandé pour les nouveaux projets. Il est présenté dans la leçon suivante.
    • Un fichier est traité comme CommonJS s'il a l'extension .cjs, ou l'extension .js dans un projet dont le package.json n'a pas "type": "module".
  3. Exporter et importer

    1. Créer un module avec module.exports
      • Chaque fichier CommonJS dispose d'un objet module.exports. Ce qu'on y place est ce que le module rend public :
      // outils.js : un module CommonJS
      const TVA = 0.19;
      
      function prixTTC(prixHT) {
        return Math.round(prixHT * (1 + TVA) * 100) / 100;
      }
      
      function formaterPrix(montant) {
        return `${montant.toFixed(2)} DT`;
      }
      
      console.log('Chargement du module outils.js');
      
      module.exports = { TVA, prixTTC, formaterPrix };
    2. TVA, prixTTC et formaterPrix sont exportés. Une variable déclarée dans le fichier sans être exportée resterait invisible pour les autres fichiers.
    3. Charger un module avec require()
      • require() exécute le fichier demandé (la première fois) et renvoie son module.exports. On récupère souvent les éléments utiles par déstructuration:
      // app.js : utilise le module outils.js
      const { prixTTC, formaterPrix } = require('./outils');
      const outils = require('./outils');          // deuxième require : module déjà en cache
      const path = require('node:path');
      
      console.log(formaterPrix(prixTTC(100)));
      console.log(`TVA : ${outils.TVA * 100} %`);
      console.log(`Ce fichier : ${path.basename(__filename)}, dans ${path.basename(__dirname)}`);
      node app.js
      Chargement du module outils.js
      119.00 DT
      TVA : 19 %
      Ce fichier : app.js, dans cjs
    4. Le chemin d'un fichier du projet commence par ./ ou ../. L'extension .js peut être omise : require('./outils') trouve outils.js.
    5. __filename et __dirname donnent le chemin du fichier en cours et de son dossier.
    6. Exporter une seule valeur
      • Un module peut aussi exporter une seule valeur, par exemple une classe ou une fonction, en remplaçant module.exports:
      // compteur.js : exporter une seule valeur (ici une classe)
      class Compteur {
        #valeur = 0;
        incrementer() { return ++this.#valeur; }
      }
      module.exports = Compteur;
      const Compteur = require('./compteur');
      const c = new Compteur();
      c.incrementer();
      console.log(c.incrementer());   // 2
    7. Charger un fichier JSON
      • require() lit et convertit aussi directement un fichier JSON :
      // config.json contient : { "nom": "boutique", "port": 3000 }
      const config = require('./config.json');
      console.log(config.nom, config.port);   // boutique 3000
  4. Les trois sortes de modules

  5. SorteÉcritureOù Node.js le cherche
    Vos fichiersrequire('./outils'), require('../config.json')Au chemin indiqué, relatif au fichier qui fait le require
    Modules natifsrequire('node:fs'), require('node:path')Dans Node.js lui-même : rien à installer (leçon 4.8)
    Paquets npmrequire('dayjs'), require('express')Dans node_modules du dossier courant, puis des dossiers parents
  • Le préfixe node: est facultatif (require('fs') fonctionne), mais il est recommandé : il indique clairement qu'il s'agit d'un module natif.
  • Si Node.js ne trouve rien, il s'arrête avec l'erreur Cannot find module './outil' (code MODULE_NOT_FOUND) : vérifiez le chemin, ou installez le paquet avec npm.
  • Le cache des modules

    • Dans app.js, outils.js est chargé deux fois avec require(), pourtant le message « Chargement du module outils.js » ne s'affiche qu'une fois.
    • Node.js exécute un module au premier require(), puis garde le résultat en cache. Les require() suivants renvoient le même objet, sans réexécuter le fichier. Ce fonctionnement :
      • évite de répéter un travail coûteux, comme ouvrir une connexion à la base de données ;
      • permet de partager un même état entre tous les fichiers de l'application, par exemple une seule connexion ou une configuration.
  • Comment Node.js exécute un module

    • Avant d'exécuter un fichier CommonJS, Node.js l'enveloppe dans une fonction :
    (function (exports, require, module, __filename, __dirname) {
      // le code de votre fichier
    });
  • Cela explique deux choses :
    • les variables d'un fichier sont locales à cette fonction : elles ne polluent pas les autres modules ;
    • require, module, exports, __filename et __dirname sont des paramètres de la fonction, et non de vraies variables globales. C'est pour cela qu'ils n'existent pas dans les modules ES.
  • Le piège de exports

    • Au départ, exports est un raccourci qui pointe vers le même objet que module.exports. On peut donc ajouter des propriétés à exports, mais pas le réaffecter:
    // piege.js : réaffecter exports ne fonctionne pas
    exports.a = 1;              // OK : ajoute une propriété à module.exports
    exports = { b: 2 };         // sans effet : exports ne pointe plus vers module.exports
    console.log(require('./piege'));   // { a: 1 }
  • Après exports = { b: 2 }, la variable exports désigne un nouvel objet, mais Node.js renvoie toujours module.exports, qui ne contient que a.
  • Règle simple : utilisez toujours module.exports, de préférence une seule fois, à la fin du fichier.
  • Activité 1 : un module de validation

    • Dans un dossier CommonJS, créez validation.js, qui exporte :
      • estEmailValide(texte): true si le texte contient un @ suivi d'un point ;
      • estMotDePasseFort(texte): true si le texte fait au moins 8 caractères et contient un chiffre.
      Utilisez-les dans index.js pour vérifier sara@exemple.tn et abc123.
    • Voir le corrigé
      // validation.js
      function estEmailValide(texte) {
        return /^[^@\s]+@[^@\s]+\.[^@\s]+$/.test(texte);
      }
      
      function estMotDePasseFort(texte) {
        return texte.length >= 8 && /\d/.test(texte);
      }
      
      module.exports = { estEmailValide, estMotDePasseFort };
      // index.js
      const { estEmailValide, estMotDePasseFort } = require('./validation');
      
      console.log(estEmailValide('sara@exemple.tn'));   // true
      console.log(estMotDePasseFort('abc123'));         // false : moins de 8 caractères
  • Activité 2 : le cache en action

    • Créez compteur-partage.js, qui exporte un objet { visites: 0 }. Dans a.js, incrémentez visites; dans main.js, chargez a.js, puis compteur-partage.js, et affichez visites. Quelle valeur s'affiche, et pourquoi ?
    • Voir le corrigé
      // compteur-partage.js
      module.exports = { visites: 0 };
      
      // a.js
      const compteur = require('./compteur-partage');
      compteur.visites++;
      
      // main.js
      require('./a');
      const compteur = require('./compteur-partage');
      console.log(compteur.visites);   // 1

      La valeur affichée est 1. compteur-partage.js n'est exécuté qu'une fois : a.js et main.js reçoivent le même objet, depuis le cache. La modification faite dans a.js est donc visible dans main.js.

  • À retenir

    • Un module CommonJS rend public ce qu'il place dans module.exports; tout le reste est privé.
    • require() charge vos fichiers (./), les modules natifs (node:) et les paquets npm (node_modules), ainsi que les fichiers JSON.
    • Un module n'est exécuté qu'une fois : les require() suivants renvoient le même objet, depuis le cache.
    • Ne réaffectez jamais exports: utilisez module.exports.
  • Testez-vous

    • 1. Quelle est la différence entre require('./outils') et require('outils')?
    • 2. Pourquoi un message affiché dans un module n'apparaît-il qu'une fois, même si on le charge plusieurs fois ?
    • 3. Qu'affiche require('./m') si m.js contient exports.x = 1; exports = { y: 2 };?
    • 4. Pourquoi __dirname fonctionne-t-il en CommonJS sans être déclaré ?
    • Voir les réponses
      1. ./outils désigne un fichier du projet ; outils désigne un paquet cherché dans node_modules.
      2. Parce que Node.js exécute le module au premier chargement, puis le garde en cache.
      3. { x: 1 }: la réaffectation de exports n'a aucun effet sur module.exports.
      4. Parce que Node.js enveloppe chaque fichier dans une fonction qui reçoit __dirname en paramètre.
  • Cet article vous a-t-il aidé ?