Comment fonctionne le cache de modules sur NodeJS

Node.js possède un mécanisme de mise en cache des modules qui permet d'améliorer les performances des applications en évitant de recharger et de réexécuter le code des modules déjà importés.

Voyons ce mécanisme ensemble, en détails.

Comment fonctionne la mise en cache des modules ?

Lorsqu'un module est importé à l'aide de require(), Node lit et exécute le fichier correspondant, puis met en cache son exportation.

Si le même module est importé à nouveau dans un autre fichier ou dans le même fichier, Node.js ne réexécute pas son code mais renvoie directement la version mise en cache.

Prenons un exemple simple pour illustrer ce mécanisme.

Créons un fichier hello.js contenant une fonction d'affichage et un console.log() en dehors de cette fonction :

console.log("Module chargé");

function hello(name) {
    console.log("Hello " + name);
}

module.exports = hello;

Ensuite, importons ce module plusieurs fois dans un autre fichier :

const hello1 = require('./hello.js');
const hello2 = require('./hello.js');
const hello3 = require('./hello.js');

hello1("one");
hello2("two");
hello3("three");

Module chargé
Hello one
Hello two
Hello three

On observe ici que la ligne console.log("Module chargé") n'est exécutée qu'une seule fois, alors que la fonction hello() est bien appelée à chaque invocation.

Pourquoi cette mise en cache ?

Ce mécanisme offre plusieurs avantages :

1. Performance améliorée : évite de relire et de réexécuter inutilement le même fichier.
2. Économie de mémoire : réduit la duplication des objets en mémoire.
3. Partage des états : les modules exportant des objets ou des instances de classes conservent leur état à travers toutes les importations.

Gestion manuelle du cache

Comment fonctionne le cache ?

Node.js stocke les modules chargés dans un objet global appelé require.cache

Cet objet contient des références aux modules importés, permettant de les réutiliser sans avoir à les recharger. On peut examiner le cache des modules chargés en affichant require.cache :

console.log(require.cache);

{
  '/Users/username/module/hello.js': //key
      Module {
          id: '/Users/username/module/hello.js',
          exports: [Function: hello],
          parent: { /* ... */},
          filename: '/Users/username/module/hello.js',
          loaded: true,
          children: [],
          paths: [/* ... */]
      }
}

Chaque clé de cet objet correspond au chemin absolu du module chargé.

Et sa valeur est un objet représentant les métadonnées du module.

Comment supprimer un module du cache ?

Dans certains cas, il peut être nécessaire de forcer le rechargement d'un module, par exemple lorsqu'on effectue des modifications dynamiques.

Cela peut être réalisé en supprimant l'entrée du cache, comme ceci :

delete require.cache[require.resolve('./hello.js')];
const helloReloaded = require('./hello.js');

Cette approche doit être utilisée avec précaution, car elle peut introduire des incohérences dans l'application.