ES et CommonJS

Standard

JavaScript est un langage qui a évolué pour devenir un standard universel dans le développement web et backend. Cependant, son écosystème a connu des étapes clés dans la manière de structurer et d'importer du code. Deux systèmes majeurs d'organisation des modules se détachent : CommonJS et ECMAScript Modules (ESM).

CommonJS

Avant l'introduction d'ESM, Node.js a créé son propre système de modules : CommonJS. C'est ce système qui a permis d'utiliser JavaScript sur le backend et qui est devenu la norme défacto pour Node.js.

• Syntaxe de CommonJS : Les modules sont importés avec require et exportés avec module.exports ou exports.

// Importation
const math = require('./math');

// Utilisation
const result = math.add(2, 3);
console.log(`La somme est ${result}`);

// Exportation (math.js)
module.exports = {
  add: (a, b) => a + b,
};

ECMAScript

ECMAScript (ou ES) est une norme standardisée pour le langage JavaScript. Elle a été développée pour assurer la cohérence entre les différentes implémentations de JavaScript et étendre ses fonctionnalités de manière standard.

• Introduction d'ESM (ECMAScript Modules) : Avec ES6 (ou ES2015), un système de modules natif a été introduit dans JavaScript. Les modules ECMAScript permettent de charger et d'exporter des morceaux de code en utilisant les mots-clés import et export.

// Importation
import { add } from './math.js';

// Utilisation
const result = add(2, 3);
console.log(`La somme est ${result}`);

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

Pourquoi ces deux systèmes existent-ils ?

CommonJS

• Origine : Créé spécifiquement pour Node.js afin de fournir un système de modules simple et fonctionnel pour les applications backend.
• Avantages :
  • Simple à utiliser et largement adopté dans l'écosystème Node.js.
  • Fonctionne nativement dans Node.js sans configuration supplémentaire.
  • Bonne prise en charge des modules dynamiques.
• Limites :
  • Pas adapté pour les navigateurs sans outils de transpilation.

ECMAScript Modules

• Origine : Standardisé par ECMA pour unifier l'utilisation de modules dans tous les environnements JavaScript (navigateur et backend).
• Avantages :
  • Standard universel supporté par les navigateurs modernes et Node.js.
  • Syntaxe claire et intuitive avec import et export.
  • Optimisé pour des fonctionnalités modernes comme le tree-shaking (suppression du code inutilisé).
• Limites :
  • Exige une configuration (par exemple, ajouter "type": "module" dans package.json).
  • Chargement asynchrone des modules par défaut, ce qui peut poser des problèmes dans certains contextes.

Différences principales entre CommonJS et ECMAScript Modules

Lequel utiliser ?

Utiliser CommonJS

• Lorsque vous travaillez sur des projets Node.js anciens ou utilisant des paquets qui reposent sur CommonJS.
• Si vous avez besoin d'une compatibilité immédiate sans ajustements.

Utiliser ECMAScript Modules

• Pour les nouveaux projets Node.js ou frontend qui souhaitent suivre les standards modernes.
• Lorsque vous avez besoin de fonctionnalités comme le tree-shaking ou une compatibilité avec les navigateurs.
• Si vous voulez un code préparé pour l'avenir et portable entre différents environnements.