19 mai 2023

Modules, introduction

Au fur et à mesure que notre application grandit, nous souhaitons la scinder en plusieurs fichiers, appelés “modules”. Un module contient généralement une classe ou une bibliothèque de fonctions pour une tâche précise.

Pendant longtemps, JavaScript n’avait pas de module. Ce n’était pas un problème, car au départ les scripts étaient petits et simples, il n’était donc pas nécessaire.

Mais les scripts sont devenus de plus en plus complexes et la communauté a donc inventé diverses méthodes pour organiser le code en modules, des bibliothèques spéciales pour charger des modules à la demande.

Pour en nommer quelques-uns (pour des raisons historiques) :

  • AMD – un des systèmes de modules les plus anciens, initialement mis en œuvre par la bibliothèque require.js.
  • CommonJS – le système de module créé pour Node.js
  • UMD – un système de module supplémentaire, proposé comme universel, compatible avec AMD et CommonJS

Maintenant, tous ces éléments deviennent lentement du passé, mais nous pouvons toujours les trouver dans d’anciens scripts.

Le système de modules au niveau du langage est apparu dans la norme en 2015, a progressivement évolué depuis, et est désormais pris en charge par tous les principaux navigateurs et dans Node.js. Nous allons donc étudier les modules JavaScript modernes à partir de maintenant.

Qu’est-ce qu’un module?

Un module n’est qu’un fichier. Un script est un module. Aussi simple que cela.

Les modules peuvent se charger mutuellement et utiliser des directives spéciales, export et import, pour échanger des fonctionnalités, appeler les fonctions d’un module dans un autre:

  • Le mot-clé export labelise les variables et les fonctions qui doivent être accessibles depuis l’extérieur du module actuel.
  • import permet l’importation de fonctionnalités à partir d’autres modules.

Par exemple, si nous avons un fichier sayHi.js exportant une fonction

// 📁 sayHi.js
export function sayHi(user) {
  alert(`Hello, ${user}!`);
}

…Un autre fichier peut l’importer et l’utiliser:

// 📁 main.js
import {sayHi} from './sayHi.js';

alert(sayHi); // function...
sayHi('John'); // Hello, John!

La directive import charge le module qui a pour chemin ./sayHi.js par rapport au fichier actuel et affecte la fonction exportée sayHi à la variable correspondante.

Lançons l’exemple dans le navigateur.

Comme les modules prennent en charge des mots-clés et des fonctionnalités spéciales, nous devons indiquer au navigateur qu’un script doit être traité comme un module, en utilisant l’attribut <script type="module">.

Comme ça:

Résultat
say.js
index.html
export function sayHi(user) {
  return `Hello, ${user}!`;
}
<!doctype html>
<script type="module">
  import {sayHi} from './say.js';

  document.body.innerHTML = sayHi('John');
</script>

Le navigateur extrait et évalue automatiquement le module importé (et, le cas échéant, ses importations), puis exécute le script.

Les modules fonctionnent uniquement via HTTP(s), pas localement

Si vous essayez d’ouvrir une page Web localement, via le protocole file://, vous verrez que les directives import/export ne fonctionnent pas. Utilisez un serveur Web local, tel que static-server ou utilisez la fonctionnalité “live server” de votre éditeur, tel que VS Code Live Server Extension pour tester les modules.

Caractéristiques du module de base

Qu’est-ce qui est différent dans les modules par rapport aux scripts “normaux”?

Il existe des fonctionnalités de base, valables à la fois pour le navigateur et le JavaScript côté serveur.

Toujours en mode “use strict”

Les modules fonctionnent toujours en mode strict. Par exemple. l’affectation à une variable non déclarée donnera une erreur.

<script type="module">
  a = 5; // error
</script>

Portée au niveau du module

Chaque module a sa propre portée globale. En d’autres termes, les variables et les fonctions globales d’un module ne sont pas visibles dans les autres scripts.

Dans l’exemple ci-dessous, deux scripts sont importés et hello.js essaie d’utiliser la variable user déclarée dans user.js. Il échoue, car il s’agit d’un module distinct (vous verrez l’erreur dans la console) :

Résultat
hello.js
user.js
index.html
alert(user); // pas de variable user (chaque module a des variables indépendantes)
let user = "John";
<!doctype html>
<script type="module" src="user.js"></script>
<script type="module" src="hello.js"></script>

Les modules doivent export ce qu’ils veulent être accessible de l’extérieur et import ce dont ils ont besoin.

  • user.js devrait exporter la variable user.
  • hello.js devrait l’importer depuis le module user.js.

En d’autres termes, avec les modules, nous utilisons l’import/export au lieu de nous appuyer sur des variables globales.

Ceci est la bonne variante :

Résultat
hello.js
user.js
index.html
import {user} from './user.js';

document.body.innerHTML = user; // John
export let user = "John";
<!doctype html>
<script type="module" src="hello.js"></script>

Dans le navigateur, si nous parlons de pages HTML, une portée de niveau supérieur indépendante existe également pour chaque <script type="module">.

Voici deux scripts sur la même page, tous deux type="module". Ils ne voient pas les variables de niveau supérieur de l’autre :

<script type="module">
  // La variable est uniquement visible dans ce module
  let user = "John";
</script>

<script type="module">
  alert(user); // Error: user is not defined
</script>
Veuillez noter :

Dans le navigateur, nous pouvons rendre une variable globale au niveau de la fenêtre en l’affectant explicitement à une propriété window, par exemple window.user = "John".

Ensuite, tous les scripts la verront, à la fois avec type="module" et sans.

Cela dit, faire de telles variables globales est mal vu. Veuillez essayer de les éviter.

Un code de module est chargé la première fois lorsqu’il est importé

Si le même module est importé dans plusieurs autres modules, son code n’est exécuté qu’une seule fois, lors de la première importation. Ensuite, ses exportations sont données à tous les autres importateurs.

L’évaluation ponctuelle a des conséquences importantes, dont nous devons être conscients.

Voyons quelques exemples.

Premièrement, si exécuter un code de module entraîne des effets secondaires, comme afficher un message, l’importer plusieurs fois ne le déclenchera qu’une seule fois – la première fois:

// 📁 alert.js
alert("Module is evaluated!");
// Importer le même module à partir de fichiers différents

// 📁 1.js
import `./alert.js`; // le module est chargé

// 📁 2.js
import `./alert.js`; // (n'affiche rien)

La deuxième importation ne montre rien, car le module a déjà été évalué.

Il y a une règle : le code du module de niveau supérieur doit être utilisé pour l’initialisation, la création de structures de données internes spécifiques au module. Si nous devons rendre quelque chose appelable plusieurs fois, nous devons l’exporter en tant que fonction, comme nous l’avons fait avec sayHi ci-dessus.

Maintenant, considérons un exemple plus profond.

Disons qu’un module exporte un objet:

// 📁 admin.js
export let admin = {
  name: "John"
};

Si ce module est importé à partir de plusieurs fichiers, il n’est chargé que la première fois, un objet admin est créé, puis transmis à tous les autres importateurs.

Tous les importateurs obtiennent exactement le seul et unique objet admin:

// 📁 1.js
import {admin} from './admin.js';
admin.name = "Pete";

// 📁 2.js
import {admin} from './admin.js';
alert(admin.name); // Pete

// 1.js et 2.js font référence au même objet admin
// Les modifications apportées dans 1.js sont visibles dans 2.js

Comme vous pouvez le voir, lorsque 1.js modifie la propriété name dans le admin importé, alors