Dans ce chapitre du web schooljavascript.com vous êtes sur le point d'apprendre comment le système de modules Node.js et CommonJS fonctionne et ce que fait la fonction exiger.
CommonJS à la rescousse
Le langage JavaScript ne disposait pas d'un moyen natif d'organiser le code avant la Norme ES2015. Node.js a comblé cette lacune avec le format de module CommonJS. Dans cet article, nous allons apprendre comment fonctionne le système de modules Node.js, comment organiser vos modules et ce que la nouvelle norme ES signifie pour l'avenir de Node.js.
Quel est le système de modules?
Les modules sont les éléments fondamentaux de la structure du code. Le système de modules vous permet d'organiser votre code, de masquer des informations et d'exposer uniquement l'interface publique d'un composant en utilisant module.exports. Chaque fois que vous utilisez l'appel exiger; par conséquent, vous chargez un autre module.
L'exemple le plus simple peut être le suivant en utilisant CommonJS:
// fonction add.js add (a, b) {return a + b} module.exports = add
Pour utiliser le ajouter un module nous venons de créer, nous devons le demander.
// index.js const add = require ('./ add') console.log (add (4, 5)) // 9
Bien que ce ne soit pas perceptible, add.js il est enveloppé par Node.js comme ceci:
(function (exports, require, module, __filename, __dirname) {function add (a, b) {return a + b} module.exports = add})
C'est pourquoi vous pouvez accéder aux variables de type global comme exiger y module. Il garantit également que vos variables sont dans la portée de votre module plutôt que dans l'objet global.
Comment cela fonctionne-t-il?
Le mécanisme de chargement de module dans Node.js met en cache les modules lors du premier appel à exiger. Cela signifie que chaque fois que vous utilisez: require ('awesome-module'), vous obtiendrez la même instance de module génial, ce qui garantit que les modules sont de type singleton et avoir le même état tout au long de votre application.
Vous pouvez charger des modules natifs et des références de chemin à partir de votre système de fichiers ou des modules installés. Si l'identifiant passé à la fonction exiger Ce n'est pas un module natif, ni une référence de fichier (commençant par /, ../, ./ ou similaire), donc Node.js recherchera les modules installés. Il passera par votre système de fichiers à la recherche du module référencé dans le dossier node_modules. Il démarre à partir du répertoire principal de votre module actuel, puis se déplace vers le répertoire principal jusqu'à ce qu'il trouve le bon module, ou jusqu'à ce que la racine du système de fichiers soit atteinte.
Exiger sous le capot - module.js
Le module qui s'occupe du chargement des modules dans le noyau Node est appelé module.js, et peut être trouvé dans lib / module.js dans le référentiel Node.js.
Les fonctions les plus importantes à vérifier ici sont les fonctions _loady y _compiler.
Module _Load
Cette fonction vérifie si le module est déjà dans le cache; si tel est le cas, il renvoie l'objet d'exportation.
Si le module est natif, appelez le NativeModule.require () avec le nom de fichier et renvoie le résultat.
Sinon, il crée un nouveau module pour le fichier et le met en cache. Il charge ensuite le contenu du fichier avant de renvoyer votre objet d'exportation.
Module _Compiler
La fonction de construction exécute le contenu du fichier dans la bonne portée ou sandbox, et expose les variables d'assistance telles que exiger, module ou exportations au fichier.
Comment organiser le code?
Dans nos applications, nous devons trouver le bon équilibre entre cohésion et couplage lors de la création de modules. Le scénario souhaitable est d'obtenir une cohésion élevée et un couplage lâche des modules.
Un module doit se concentrer uniquement sur une partie de la fonctionnalité pour avoir une forte cohésion. Un couplage lâche signifie que les modules ne doivent pas avoir un état global ou partagé. Ils ont juste besoin d'être communiqués en passant les paramètres, et ils sont facilement remplaçables sans toucher à votre base de code plus large.
Nous exportons généralement les fonctions nommées ou constantes comme suit:
'use strict' const CONNECTION_LIMIT = 0 function connect () {/ * ... * /} module.exports = {CONNECTION_LIMIT, connect}
Qu'y a-t-il dans vos node_modules?
Le tapis node_modules est l'endroit où Node.js recherche les modules. npm v2 y npm v3 ils installent leurs dépendances différemment. Vous pouvez découvrir quelle version de npm vous utilisez en exécutant:
npm --version
npm v2
npm v2 installer toutes les dépendances de manière imbriquée, où les dépendances principales du package sont dans votre dossier node_modules.
npm v3
npm v3 essayez d'aplatir ces dépendances enfants et installez-les dans le dossier racine node_modules. Cela signifie que vous ne pouvez pas dire en regardant node_modules quels packages sont ses dépendances explicites ou implicites. Il est également possible que l'ordre d'installation modifie la structure de votre dossier car npm v3 ce n'est pas déterministe de cette manière.
Vous pouvez vous assurer que votre répertoire node_modules être toujours la même en installant des packages uniquement à partir d'un package.json. Dans ce cas, installez vos dépendances par ordre alphabétique, ce qui signifie également que vous obtiendrez la même arborescence de dossiers. Ceci est important car les modules sont mis en cache en utilisant votre chemin comme clé de recherche. Chaque package peut avoir son propre sous-dossier node_modules, ce qui peut entraîner plusieurs instances du même package et du même module.
Comment gérer vos modules?
Il existe deux manières principales de câbler les modules. L'un d'eux utilise des dépendances codées en dur, chargeant explicitement un module dans un autre à l'aide d'un appel de fonction exiger. L'autre méthode consiste à utiliser un modèle d'injection de dépendances, où nous transmettons les composants en tant que paramètre, ou nous avons un conteneur global (appelé IoC, ou conteneur Inversion of Control), qui centralise l'administration des modules.
Nous pouvons permettre à Node.js de gérer le cycle de vie des modules en chargeant des modules codés. Organisez vos packages de manière intuitive, ce qui facilite leur compréhension et leur débogage.
L'injection de dépendances est rarement utilisée dans un environnement Node.js, bien que ce soit un concept utile. Le modèle DI peut entraîner un découplage amélioré des modules. Au lieu de définir explicitement les dépendances d'un module, elles sont reçues de l'extérieur. Par conséquent, ils peuvent être facilement remplacés par des modules qui ont les mêmes interfaces.
Regardons un exemple pour Modules DI en utilisant le modèle d'usine:
class Cart {constructeur (options) {this.engine = options.engine} start () {this.engine.start ()}} function create (options) {return new Cart (options)} module.exports = create
Le système de modules ES2015
Comme nous l'avons vu précédemment, le système de modules CommonJS utilise l'évaluation d'exécution des modules, les enveloppant dans une fonction avant l'exécution. Il n'est pas nécessaire d'envelopper les modules ES2015 car les liens Importer / Exporter ils sont créés avant l'évaluation du module. Cette incompatibilité est la raison pour laquelle il n'existe actuellement aucun runtime JavaScript prenant en charge les modules ES. Il y a eu beaucoup de discussions sur le sujet et une proposition est à l'état de PROJET, nous espérons donc avoir du soutien dans les futures versions de Node.
