Importation de module Node.js

Lorsque vous commencez à écrire un projet Node.js, l'un des premiers problèmes que vous rencontrez est de savoir comment importer des modules.

Dans Node.js, les modules sont des fichiers JavaScript réutilisables qui communiquent entre eux par import et export.

L'écosystème Node.js prend principalement en charge deux systèmes de modules :CommonJSet modules ES (ESM)。

Système de modules Spécification Extension de fichier Méthode d'importation Méthode d'exportation
CommonJS Utilisation précoce de Node.js .js require() module.exports / exports
Module ES (ESM) Norme ECMAScript .mjsou"type": "module" import export / export default

Système de modules CommonJS

CommonJS est le système de modules le plus ancien et le plus largement utilisé dans Node.js. Il utilise un chargement synchrone, ce qui signifie que lorsqu'un module est chargé, il bloque l'exécution du programme jusqu'à ce que le chargement soit terminé.

Importation et exportation

Dans CommonJS, vous utilisezrequire()la fonction pour importer des modules, et utilisezmodule.exportsouexportsl'objet pour exporter des modules.

Méthodes d'exportation :

Code du fichier math.js :

// math.js
function add(a, b) {
  return a + b;
}

module.exports = { add };
// Ou: exports.add = add;

Méthodes d'import :

Exemple

// app.js
const math = require('./math.js');

console.log(math.add(2, 3)); // 5

Pour qu'un module permette l'accès externe à son contenu, il doit utiliser module.exports ou exports pour l'exporter :

Exemple

// user.js
const name = 'Alice';
const age = 30;

// Méthode 1 : Utiliser module.exports pour exporter un seul objet ou une valeur
module.exports = {
  name: name,
  age: age,
  sayHello: () => {
    console.log(`Bonjour, je m'appelle ${name}.`);
  }
};

// Méthode 2 : Utiliser exports pour exporter plusieurs variables nommées
// exports est une référence à module.exports
exports.name = name;
exports.age = age;
exports.sayHello = () => {
  console.log(`Bonjour, je m'appelle ${name}.`);
};

Méthodes d'import :

Exemple

// main.js
const user = require('./user.js');

console.log(user.name); // Sortie : Alice
user.sayHello(); // Sortie : Bonjour, je m'appelle Alice.

// Vous pouvez aussi déstructurer directement
const { name, age } = require('./user.js');
console.log(name); // Sortie : Alice

Fonctionnalités de CommonJS :

  • Chargement synchrone: Adapté aux environnements côté serveur car les modules se trouvent généralement dans le système de fichiers local et se chargent rapidement.
  • Chargement à l'exécution：require()Vous pouvez l'appeler n'importe où dans le code, ce qui vous permet de charger dynamiquement des modules en fonction de conditions.
  • Mécanisme de mise en cache：require()Les modules chargés sont mis en cache. Lorsqu'ils sont importés une seconde fois, ils sont lus directement depuis le cache, ce qui évite un chargement répété.

Spécification ES Module (ESM)

ESM est le standard officiel des modules JavaScript. Il utilise le chargement asynchrone et constitue le premier choix pour les navigateurs et les applications Node.js modernes.

Dans ESM, vous utilisez l'instructionimportpour importer des modules, et vous utilisez l'instructionexportpour exporter des modules.

Activation d'ESM :Pour utiliser ESM dans Node.js, vous devez ajouter"type": "module", ou changer l'extension de fichier en.mjs。

// package.json
{
  "type": "module"
}

Exportation de modules :

Exemple

// math.mjs
export function add(a, b) {
  return a + b;
}

export default function multiply(a, b) {
  return a * b;
}

Importation de modules :

Exemple

// app.mjs
import multiply, { add } from './math.mjs';

console.log(add(2, 3));      // 5
console.log(multiply(2, 3)); // 6

Comment l'activer :

  • Utiliser l'extension de fichier.mjs

  • Ou ajoutez ceci dans package.json :

    {
  "type": "module"
}

ESM prend en charge deux méthodes d'export : les exports nommés et l'export par défaut.

Exemple

// user.mjs

// Export nommé
export const name = 'Bob';
export const age = 25;

// Export par défaut
const sayHello = () => {
  console.log(`Bonjour, je m'appelle ${name}.`);
};
export default sayHello;

Méthodes d'import :

Exemple

// main.mjs

// Importer l'export nommé
import { name, age } from './user.mjs';
console.log(name); // Sortie : Bob

// Importer l'export par défaut
import sayHello from './user.mjs';
sayHello(); // Sortie : Bonjour, je m'appelle Bob.

// Importer les exports nommés et par défaut ensemble
import sayHello, { name } from './user.mjs';
console.log(name);
sayHello();

// Importer tous les exports nommés comme propriétés d'un objet
import * as user from './user.mjs';
console.log(user.name);
user.default(); // L'export par défaut sera la propriété default

Fonctionnalités ESM :

  • Chargement asynchrone: Il est asynchrone par défaut et ne bloque pas le thread principal, ce qui le rend plus adapté aux environnements de navigateur, mais dans Node.js, il se comporte généralement comme un chargement synchrone.
  • Analyse statique：importetexportLes instructions peuvent déterminer les dépendances des modules avant l'exécution du code, permettant aux outils (tels que Webpack, Vite) d'effectuer de meilleures optimisations (telles queTree Shaking）。
  • Mode strict: Les modules ESM s'exécutent en mode strict par défaut.

Différences entre CommonJS et ESM

Item CommonJS ESM
Syntaxe require / module.exports import / export
Mécanisme de chargement Chargement synchrone à l'exécution Chargement statique à la compilation
Prise en charge par défaut Pris en charge par défaut dans Node.js Besoin.mjsou"type": "module"
Scénarios adaptés Scripts backend, projets legacy Projets frontend et backend modernes, Tree-shaking
Peuvent-ils être mélangés ? Impossible de les mélanger directement (nécessite une configuration supplémentaire) Impossible de les mélanger directement (nécessite une configuration supplémentaire)

Utilisation mixte

Node.js prend en charge la coexistence des deux systèmes de modules dans les versions récentes. Vous pouvez utiliser CommonJS et ESM ensemble dans le même projet, mais vous devez prendre en compte les points suivants :

  • ESM ne peut pas utiliser directementrequire()etmodule.exports。
  • CommonJS ne peut pas utiliser directementimportetexport。

  • Si vous souhaitez importer un module CommonJS dans ESM, vous pouvez directement utiliserimportinstruction, et ESM le traitera comme un export par défaut.

    // commonjs_module.js
module.exports = { data: 'hello' };

// esm_module.mjs
import commonModule from './commonjs_module.js';
console.log(commonModule.data); // 输出: hello

  • Si vous souhaitez importer un module ESM dans CommonJS, vous devez utiliser l'import dynamiqueimport()fonction.

    // esm_module.mjs
export const name = 'Bob';

// commonjs_module.js
async function loadESM() {
  const { name } = await import('./esm_module.mjs');
  console.log(name);
}
loadESM();

Suggestions de bonnes pratiques

Pour les nouveaux projets,il est fortement recommandé d'utiliser les modules ES (ESM). Ce n'est pas seulement la norme officielle de JavaScript, mais cela offre également une meilleure compatibilité avec les chaînes d'outils front-end modernes (comme Vite, Next.js), et peut tirer pleinement parti de techniques d'optimisation telles que le Tree Shaking pour réduire la taille du code final.

Si vous maintenez un ancien projet CommonJS et que vous n'avez pas besoin des fonctionnalités ESM, vous pouvez continuer à utiliser CommonJS. Toutefois, si vous devez introduire de nouvelles dépendances ou profiter des nouvelles fonctionnalités d'ESM, vous pouvez envisager une migration progressive ou l'utilisation d'un mode mixte comme transition.

Autres extensions