Explication détaillée du module Node.js chargement_node.js

JavaScript est l'un des langages de programmation les plus utilisés au monde. C'est le langage universel du monde Web et il est utilisé par tous les navigateurs. La naissance de JavaScript remonte à l'ère Netscape. Son contenu principal a été développé à la hâte pour concurrencer Microsoft et participer à la féroce guerre des navigateurs de l'époque. En raison de sa sortie prématurée, il en résultait inévitablement des fonctionnalités moins bonnes.

Malgré son court temps de développement, JavaScript possède toujours de nombreuses fonctionnalités puissantes, sauf que chaque script partage un espace de noms global.

Une fois qu'une page Web charge du code JavaScript, elle sera injectée dans l'espace de noms global et partagera le même espace d'adressage avec tous les autres scripts chargés. Cela entraînera de nombreux problèmes de sécurité, des conflits et certains problèmes courants. difficile à suivre et difficile à résoudre.

Mais heureusement, Node a défini certaines spécifications pour JavaScript côté serveur et a également implémenté le standard de module CommonJS. Dans cette norme, chaque module a son propre contexte et se distingue des autres modules. Cela signifie que les modules ne pollueront pas la portée globale, car il n’existe pas de portée globale et les modules n’interféreront pas les uns avec les autres.

Dans ce chapitre, nous découvrirons plusieurs modules différents et comment les charger.

Diviser votre code en une série de modules bien définis peut vous aider à prendre le contrôle de votre application. Ci-dessous, nous apprendrons comment créer et utiliser vos propres modules.

Découvrez comment Node charge les modules

Dans Node, les modules peuvent être référencés par chemin de fichier ou nom de module. Si un module non principal est référencé par son nom, Node mappera éventuellement le nom du module sur le chemin de fichier du module correspondant. Les modules de base qui contiennent des fonctions de base seront préchargés au démarrage de Node.

Les modules non essentiels incluent des modules tiers installés à l'aide de NPM (Node Package Manager), ainsi que des modules locaux créés par vous ou vos collègues.

Chaque module importé par le script actuel exposera un ensemble d'API publiques aux programmeurs. Avant d'utiliser le module, vous devez utiliser la fonction require pour l'importer, comme ceci :

Copier le code Le code est le suivant :

var module = require('nom_module')

Le code ci-dessus importera un module nommé module_name, qui peut être un module principal ou un module installé avec NPM. La fonction require renvoie un objet contenant toutes les API publiques du module. Selon le module, l'objet renvoyé peut être n'importe quelle valeur JavaScript, une fonction ou un objet contenant une série de propriétés (une fonction, un tableau ou tout objet JavaScript).

Module Exporter

Le système de modules CommonJS est le seul moyen de partager des objets et des fonctions entre fichiers sous Node. Pour un programme très complexe, vous devez restructurer certaines classes, objets ou fonctions en une série de modules réutilisables bien définis. Pour l'utilisateur du module, le module expose uniquement le code que vous spécifiez.

Dans l'exemple suivant, vous apprendrez qu'il existe une correspondance biunivoque entre les fichiers et les modules dans Node. Nous avons créé un fichier appelé circle.js, qui exporte uniquement le constructeur Circle.

Copier le code Le code est le suivant :

fonction Cercle(x, y, r) {

fonction r_squared() {

return Math.pow(r, 2);

}

zone de fonction() {

return Math.PI * r_squared();

}

retourner {zone: zone};

}

module.exports = Cercle;

La ligne la plus importante du code est la dernière ligne, qui définit ce que le module exporte. module est une variable spéciale, qui représente le module actuel lui-même, et module.exports est l'objet exporté par le module. Il peut s'agir de n'importe quel objet. Dans cet exemple, nous avons exporté le constructeur de Circle afin que les utilisateurs du module puissent utiliser ce module. Encerclez les instances.

Vous pouvez également exporter certains objets complexes. module.exports est initialisé comme un objet vide. Vous pouvez exporter tout contenu que vous souhaitez exposer au monde extérieur en tant qu'attributs de l'objet module.exports. Par exemple, vous concevez un module qui expose un ensemble de fonctions :

Copier le code Le code est le suivant :

fonction printA() {

console.log('A');

}

fonction printB() {

console.log('B');

}

fonction printC() {

console.log('C');

}

module.exports.printA = printA;

module.exports.printB = printB;

module.exports.pi = Math.PI;

Ce module exporte deux fonctions (printA et printB) et un nombre (pi). Le code appelant ressemble à ceci :

Copier le code Le code est le suivant :

var monModule2 = require('./myModule2');

monModule2.printA(); // ->

monModule2.printB(); // ->

console.log(myModule2.pi); // -> 3.141592653589793

Charger le module

Comme mentionné précédemment, vous pouvez utiliser la fonction require pour charger des modules. Vous n'avez pas à vous soucier du fait que l'appel de require dans le code affectera l'espace de noms global, car il n'y a pas de concept d'espace de noms global dans Node. Si le module existe et qu'il n'y a aucune erreur de syntaxe ou d'initialisation, la fonction require renverra l'objet module et vous pourrez affecter cet objet à n'importe quelle variable locale.

Il existe plusieurs types de modules, qui peuvent être grossièrement divisés en modules de base, modules locaux et modules tiers installés via NPM. Selon le type de module, il existe plusieurs façons de référencer le module. ces connaissances.

Charger le module de base

Node contient certains modules qui sont compilés dans des fichiers binaires, appelés modules de base. Ils ne peuvent pas être référencés via des chemins, uniquement par des noms de modules. Le module principal a la priorité de chargement la plus élevée. Même s'il existe un module tiers portant le même nom, le module principal sera chargé en premier.

Par exemple, si vous souhaitez charger et utiliser le module http core, vous pouvez faire ceci :

Copier le code Le code est le suivant :

        var http = require('http');

Cela renverra un objet module http, qui contient l'API du module htpp définie dans la documentation de l'API Node.

Charger le module de fichiers

Vous pouvez également charger des modules depuis le système de fichiers en utilisant des chemins absolus :

Copier le code Le code est le suivant :

var monModule = require('/home/pedro/my_modules/my_module');

Vous pouvez également utiliser un chemin relatif basé sur le fichier actuel :

Copier le code Le code est le suivant :

var monModule = require('../my_modules/my_module');

var monModule2 = require('./lib/my_module_2');

Faites attention au code ci-dessus. Vous pouvez omettre l'extension du nom de fichier. Si Node ne trouve pas le fichier, il tentera de rechercher à nouveau en ajoutant le suffixe js après le nom du fichier (Note du traducteur : en fait, dans en plus de js, il recherchera également json et node, veuillez vous référer à la documentation du site officiel pour plus de détails), donc, s'il y a un fichier appelé my_module.js dans le répertoire courant, il y aura les deux méthodes de chargement suivantes :

Copier le code Le code est le suivant :

var monModule = require('./my_module');

var monModule = require('./my_module.js');

Charger le module d'annuaire

Vous pouvez également utiliser le chemin d'accès à un répertoire pour charger des modules :

Copier le code Le code est le suivant :

var monModule = require('./myModuleDir');

Node supposera que ce répertoire est un package de module et essaiera de rechercher le fichier de définition du package package.json dans ce répertoire.

S'il n'est pas trouvé, Node supposera que le point d'entrée du package est le fichier index.js (Note du traducteur : en plus d'index.js, il recherchera également index.node. Le fichier .node est le binaire package d'extension de Node. Voir la documentation officielle pour plus de détails), en prenant le code ci-dessus comme exemple, Node essaiera de trouver le fichier ./myModuleDir/index.js.

Au contraire, si le fichier package.json est trouvé, Node tentera de l'analyser, recherchera l'attribut principal dans la définition du package, puis utilisera la valeur de l'attribut principal comme chemin relatif du point d'entrée . Dans cet exemple, si package.json est défini comme suit :

Copier le code Le code est le suivant :

                                                        {

"nom" : "monModule",

"main" : "./lib/myModule.js"

            }

Node tentera de charger le fichier ./myModuleDir/lib/myModule.js

Charger depuis le répertoire node_modules

Si le paramètre de la fonction require n'est pas un chemin relatif ou un nom de module principal, Node recherchera dans le sous-répertoire node_modules du répertoire courant. Par exemple, dans le code suivant, Node tentera de trouver le fichier./. node_modules/myModule.js :

Copier le code Le code est le suivant :

var monModule = require('myModule.js');

S'il n'est pas trouvé, Node continuera à chercher dans le dossier node_modules du répertoire de niveau supérieur. S'il n'est pas encore trouvé, il continuera à chercher dans le répertoire de niveau supérieur jusqu'à ce que le module correspondant soit trouvé ou dans le répertoire racine. est atteint.
Vous pouvez utiliser cette fonctionnalité pour gérer le contenu ou les modules du répertoire node_modules, mais il est préférable de laisser les tâches de gestion des modules à NPM (voir Chapitre 1. Le répertoire local node_modules est l'emplacement par défaut dans lequel NPM installe les modules). Ce nœud de conception et NPM sont liés ensemble. Habituellement, en tant que développeur, vous n'avez pas besoin de trop vous soucier de cette fonctionnalité, vous pouvez simplement utiliser NPM pour installer, mettre à jour et supprimer des packages, et il conservera le répertoire node_modules pour vous

Module Cache

Les modules seront mis en cache après le premier chargement réussi, c'est-à-dire que si le nom du module est résolu selon le même chemin de fichier, alors chaque appel à require('myModule') renverra exactement le même module.

Par exemple, il existe un module appelé my_module.js, qui contient le contenu suivant :

Copier le code Le code est le suivant :

console.log('module mon_module initialisation...');
module.exports = function() {

console.log('Salut !');

};

console.log('mon_module initialisé.');

Chargez ensuite le module avec le code suivant :

Copier le code Le code est le suivant :

var monModuleInstance1 = require('./my_module');

Il produit le résultat suivant :

Copier le code Le code est le suivant :

module my_module initialisation...
mon_module initialisé

Si on l'importe deux fois :

Copier le code Le code est le suivant :

var monModuleInstance1 = require('./my_module');
var monModuleInstance2 = require('./my_module');

La sortie est toujours :

Copier le code Le code est le suivant :

module my_module initialisation...
mon_module initialisé

En d’autres termes, le code d’initialisation du module n’est exécuté qu’une seule fois. Lorsque vous créez vos propres modules, veillez à accorder une attention particulière à cette fonctionnalité si le code d'initialisation du module contient du code susceptible de produire des effets secondaires.

Résumé

Node annule la portée globale par défaut de JavaScript et adopte le système de modules CommonJS afin que vous puissiez mieux organiser votre code et éviter de nombreux problèmes de sécurité et bugs. Vous pouvez utiliser la fonction require pour charger des modules principaux, des modules tiers ou charger vos propres modules à partir de fichiers et de répertoires

Vous pouvez également utiliser des chemins relatifs ou absolus pour charger des modules non essentiels. Si vous placez le module dans le répertoire node_modules ou pour les modules installés avec NPM, vous pouvez également utiliser directement le nom du module pour le charger.

Note du traducteur :

Il est recommandé aux lecteurs de lire le chapitre sur le module du document officiel. Je pense personnellement qu'il est plus clair et plus clair que l'auteur. Il joint également un exemple très représentatif, qui sera très utile pour comprendre le chargement du module Node. Citons cet exemple :

Copier le code Le code est le suivant :

Utilisez require(X) pour charger le module sous le chemin Y

1. Si X est un module de base,

a. Charger et renvoyer le module principal

b. Fin

2. Si X commence par './' ou '/' ou '../'

a.LOAD_AS_FILE(Y X)

b.LOAD_AS_DIRECTORY(Y X)

3. LOAD_NODE_MODULES(X, nom de répertoire(Y))

4. Lever une exception : "introuvable"

LOAD_AS_FILE(X)

1. Si X est un fichier, chargez X en tant que script JavaScript et terminez après le chargement

2. Si X.js est un fichier, chargez X.js en tant que script JavaScript et terminez après le chargement

3. Si X.node est un fichier, chargez X.node en tant que plug-in binaire Node et terminez une fois le chargement terminé

LOAD_AS_DIRECTORY(X)

1. Si le fichier X/package.json existe,

a. Analysez X/package.json et recherchez le champ "principal".

b. Un autre M = X (la valeur du champ principal)

c.LOAD_AS_FILE(M)

2. Si le fichier X/index.js existe, chargez X/index.js en tant que script JavaScript et terminez après le chargement

3. Si le fichier X/index.node existe, chargez X/index.node en tant que plug-in binaire Node et terminez une fois le chargement terminé

LOAD_NODE_MODULES(X, DÉBUT)

1. Aussi DIRS=NODE_MODULES_PATHS(START)

2. Effectuez les opérations suivantes pour chaque répertoire DIR sous DIRS :

une.LOAD_AS_FILE(DIR/X)

b.LOAD_AS_DIRECTORY(DIR/X)

NODE_MODULES_PATHS(START)

1. Une autre PARTS = chemin divisé (START)

2. Une autre ROOT = index de première instance de "node_modules" dans PARTS, soit 0

3. I = nombre de PIÈCES - 1

4. Un autre DIRS = []

5. pendant que je >

a. Si PARTS[I] = "node_modules", continuez l'opération suivante, sinon elle bouclera la prochaine fois

c. DIR = chemin rejoindre(PARTS[0 .. I] "node_modules")

b.DIRS = DIRS DIR

c. Un autre I = I - 1

6. Retour au DIRS