Formation Node.js | Maîtriser les Modules

Qu’est-ce qu’un module ?

En JavaScript, les modules permettent de diviser un programme en parties plus petites et indépendantes qui peuvent être réutilisées dans d’autres parties du programme.

Un module est représenté par un fichier .js qui peut exporter des variables, des fonctions, des objets, etc., qui peuvent être importées dans d’autres modules.

De ce fait, chaque module a son propre contexte. Il ne peut donc pas interférer avec d’autres modules ni polluer la portée globale.

Cela permet de structurer et d’organiser le code de manière plus claire et de prévenir les conflits de noms entre les différentes parties du programme.

2 grandes normes

Il existe plusieurs façons d’implémenter des modules en JavaScript. Les deux grandes méthodes d’implémentation sont ES Modules et CommonJS.

ESM

Les modules ECMAScript (souvent abrégés ESM) sont intégrés dans la spécification ECMAScript 6 (ES6) et sont de plus en plus populaires pour la création de modules en JavaScript. Il s’agit donc de modules natifs à JS.

• On exporte du contenu avec le mot-clé export
• On importe du contenu avec le mot-clé import

CommonJS

La norme CommonJS est un standard pour les modules JavaScript qui a été initialement développé pour les applications Node.js côté serveur. Il a été créé en 2009 en réponse à un besoin de méthodes fiables pour partager du code et organiser des applications plus grandes et plus complexes en JavaScript.

• On exporte du contenu avec le mot-clé module.exports
• On importe du contenu avec le mot-clé require

Node implémente par défaut les modules CommonJS.

3 grands types de modules

Dans un projet Node, on distingue trois grands types de modules : « Core Modules », « Local Modules » et « Third-Party Modules ».

1. Core Modules

Les Core Modules sont les modules fournis par défaut avec Node.js. Ils constituent les fonctionnalités élémentaires du runtime.

Bien que ces modules fassent partie intégrante du langage, ils doivent être importés avant de pouvoir être utilisés dans le code.

Le tableau suivant répertorie certains des Core Modules principaux de Node.js.

2. Local Modules

Les modules locaux sont des modules créés localement (par vous) dans votre application Node.js.

Ces modules incluent différentes fonctionnalités de votre application dans des fichiers et dossiers distincts.

3. Third-Party Modules

Vous pouvez également décider de packager et de distribuer vos modules locaux afin que la communauté Node.js puisse les utiliser : ils deviendront alors des third-party modules (modules tiers).

Nous détaillerons comment installer des modules tiers via le gestionnaire de paquets npm au chapitre suivant.

Création et exportation d’un module

Créer un fichier 📄 module1.js dans le dossier 📁 my_modules et placer le code suivant à l’intérieur :

module.exports = function() {
	return "Hello World!";
};

module.exports, permettant d’exporter des éléments (variables, fonctions, classes…) à l’extérieur du fichier. La fonction anonyme va ainsi être utilisable depuis un autre fichier.

Si vous souhaitez exporter plusieurs éléments (variables, fonctions, classes…) depuis votre module, on rassemblera ces éléments au sein d’un objet littéral JS.

module.exports = {
	helloWorld: function() {
		return "Hello World!";
	},
	username: "toto"
};

Importation et utilisation d’un module

Pour importer un module CommonJS, on procède en déclarant une constante vouée à recevoir le contenu du module, chargé via la fonction require().

const module = require('module_name'); // Core/third-party module
const welcome = require('./my_modules/module1'); // Local module

Import complet

L’import complet d’un module consiste par définition à importer l’ensemble de son contenu.

const module = require("./my_modules/module_name");

// Si le module exporte une seule valeur
console.log(module);

// Si le module exporte une seule fonction
console.log(module('blabla'));

// Si le module exporte un objet
console.log(module.proriete);
console.log(module.fonction());

Import partiel

L’import partiel d’un module consiste à importer uniquement les éléments qui nous intéressent. Cela est rendu possible via le principe de la déstructuration.

Cette extraction est rendue possible via l’emploi d’accolades { }.

const { maVariable, maFonction } = require("./my_modules/module_name");

console.log(maVariable);
console.log(maFonction());

Cas concret

Pour illustrer pleinement le concept de module, créons un module local 📄 welcome.js dans le dossier 📁 my_modules exportant :

• version : version de notre module
• welcoming() : fonction saluant dans la langue souhaitée : « Bonjour » (fr), « Hello » (en) ou encore « Hola » (es)
• availableLanguages() : fonction retournant la liste des langages pris en charge par la fonction welcoming()

const words = {
	"fr": "Bonjour",
	"en": "Hello",
	"es": "Hola"
};

module.exports = {
	version: 1.2,
	welcoming: function(lang = 'en') {
		return words[lang];
	},
	availableLanguages: function() {
		return Object.keys(words);
	}
};

Depuis notre serveur 📄 server.js, on importe uniquement les fonctions availableLanguages() et welcoming() :

const http = require("http"); // Et oui, ce fameux "http" est donc un Core Module !
const { availableLanguages, welcoming } = require('./my_modules/welcome');

const hostname = '127.0.0.1';
const port = 3000;

const server = http.createServer((req, res) => {
	res.statusCode = 200;
	res.setHeader('Content-Type', 'text/plain');
	console.log(version); // ❌ non importé
	console.log(availableLanguages()); // ✅ importé
	res.end(welcoming('fr')); // ✅ importé
});

server.listen(port, hostname, () => {
	console.log(`Serveur démarré sur http://${hostname}:${port}/`);
});