JavaScript est l'un des langages de programmation les plus fréquemment utilisés au monde. C'est la langue commune dans le monde du Web et est utilisée par tous les navigateurs. La naissance de JavaScript remonte à l'ère de Netscape, et son contenu principal a été développé à la hâte pour lutter contre Microsoft et participer à la guerre de navigateur féroce à l'époque. En raison de la version prématurée, certaines de ses mauvaises fonctionnalités ont inévitablement abouti.
Bien que son temps de développement soit court, JavaScript possède toujours de nombreuses fonctionnalités puissantes, à l'exception de la fonctionnalité du partage d'un espace de noms global pour chaque script.
Une fois la page Web chargée de code JavaScript, il est injecté dans l'espace de noms global et partagera le même espace d'adresse que tous les autres scripts chargés, ce qui entraînera de nombreux problèmes de sécurité, conflits et certains problèmes courants, ce qui rend les bogues difficiles à suivre et difficiles à résoudre.
Mais heureusement, Node a défini certaines spécifications pour JavaScript côté serveur et implémente également la norme du 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'y a pas du tout la portée globale, et les modules n'interfèrent pas entre eux.
Dans ce chapitre, nous découvrirons plusieurs modules différents et comment les charger.
La division du code en une série de modules bien définis peut vous aider à contrôler votre application. Ci-dessous, nous apprendrons à créer et à utiliser vos propres modules.
Apprenez comment Node charge les modules
Dans le nœud, les modules peuvent être référencés via des chemins de fichier ou des noms de modules. Si un module non core est référencé par nom, le nœud finira par faire allusion le nom du module au chemin de fichier du module correspondant. Et ces modules de base contenant des fonctions centraux seront préchargés au début du nœud.
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 exposé au programmeur. Avant d'utiliser le module, vous devez utiliser la fonction Require pour l'importer, comme ceci:
La copie de code est la suivante:
var module = require ('module_name')
Le code ci-dessus importera un module nommé module_name. Il peut s'agir d'un module de base ou d'un module installé avec NPM. La fonction requise renvoie un objet contenant toutes les API publiques du module. Selon le module, l'objet renvoyé peut être n'importe quelle valeur JavaScript, il peut être une fonction ou un objet contenant une série d'attributs (fonctions, tableaux ou tout objet JavaScript).
Module d'exportation
Le système de module CommonJS est le seul moyen de partager des objets et des fonctions entre les fichiers sous nœud. Pour un programme très complexe, vous devez reconstruire certaines classes, objets ou fonctions dans une série de modules réutilisables bien définis. Pour les utilisateurs du module, le module expose uniquement le code que vous avez spécifié au monde extérieur.
Dans l'exemple suivant, vous comprendrez que dans le nœud, les fichiers et les modules correspondent un par un. Nous avons créé un fichier appelé Circle.js, qui exporte uniquement le constructeur Circle vers l'extérieur.
La copie de code est la suivante:
fonction Cercle (x, y, r) {
fonction r_squared () {
return math.pow (r, 2);
}
zone de fonction () {
return math.pi * r_squared ();
}
return {zone: zone};
}
module.exports = cercle;
La chose la plus importante dans le code est la dernière ligne, qui définit ce que le module exporte vers l'extérieur. Le module est une variable spéciale, qui représente le module actuel lui-même, et module.Exports est un objet exporté du module. Cela peut être n'importe quel objet. Dans cet exemple, nous exportons le constructeur Circle afin que les utilisateurs du module puissent utiliser ce module pour créer des instances de cercle.
Vous pouvez également exporter des objets complexes, module.Exports est initialisé dans un objet vide et vous exportez tout ce que vous souhaitez exposer au monde extérieur comme les attributs de l'objet module.exports. Par exemple, vous avez conçu un module qui expose un ensemble de fonctions à l'extérieur:
La copie de code est la suivante:
fonction pria () {
console.log ('a');
}
fonction printb () {
console.log ('b');
}
fonction printc () {
console.log ('c');
}
module.exports.printa = pria;
module.exports.printb = printb;
module.exports.pi = math.pi;
Ce module exporte deux fonctions (printa et printb) et un nombre (pi), et le code d'appel ressemble à ceci:
La copie de code est la suivante:
var mymodule2 = require ('./ mymodule2');
mymodule2.printa (); // -> A
mymodule2.printb (); // -> b
console.log (mymodule2.pi); // -> 3.141592653589793
Module de chargement
Comme mentionné précédemment, vous pouvez utiliser la fonction Require pour charger des modules et ne vous inquiétez pas que l'appel exige dans le code affectera l'espace de noms global, car il n'y a pas de concept d'espace de noms global dans le nœud. Si le module existe sans aucune syntaxe ou erreurs d'initialisation, la fonction requise renvoie l'objet module et vous pouvez également attribuer cet objet à n'importe quelle variable locale.
Il existe plusieurs types de modules, qui peuvent être à peu près 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 se référer aux modules. Apprenons ces connaissances ci-dessous.
Chargement du module de base
Le nœud a des modules compilés dans des fichiers binaires, appelés modules de base. Ils ne peuvent pas être référencés par des chemins et ne peuvent être utilisés qu'avec des noms de modules. Le module de base a la priorité de chargement la plus élevée, et même s'il y a déjà un module tiers du même nom, le module de base sera chargé en premier.
Par exemple, si vous souhaitez charger et utiliser le module CORE HTTP, vous pouvez le faire:
La copie de code est la suivante:
var http = require ('http');
Cela renverra un objet contenant le module HTTP, qui contient les API de ces modules HTTP définis dans la documentation de l'API du nœud.
Chargement du module de fichier
Vous pouvez également utiliser des chemins absolus pour charger des modules à partir du système de fichiers:
La copie de code est la suivante:
var mymodule = require ('/ home / pedro / my_modules / my_module');
Vous pouvez également utiliser un chemin relatif basé sur le fichier actuel:
La copie de code est la suivante:
var mymodule = require ('../ my_modules / my_module');
var mymodule2 = require ('./ lib / my_module_2');
Faites attention au code ci-dessus. Vous pouvez omettre l'extension du nom du fichier. Si Node ne peut pas trouver ce fichier, vous essairez d'ajouter un suffixe JS pour rechercher à nouveau après le nom du fichier (Note du traducteur: en fait, en plus de JS, vous rechercherez également JSON et Node. Pour plus de détails, vous pouvez voir la documentation officielle du site Web). Par conséquent, si un fichier appelé my_module.js existe dans le répertoire actuel, il y aura deux méthodes de chargement:
La copie de code est la suivante:
var mymodule = require ('./ my_module');
var mymodule = require ('./ my_module.js');
Chargement du module de répertoire
Vous pouvez également utiliser le chemin du répertoire pour charger le module:
La copie de code est la suivante:
var mymodule = requis ('./ mymoduledir');
Le nœud supposera que ce répertoire est un package de module et essaie de rechercher le package de fichiers de définition de package.json dans ce répertoire.
S'il n'est pas trouvé, le nœud supposera que le point d'entrée du package est le fichier index.js (Remarque du traducteur: En plus d'index.js, il recherchera également index.node, et le fichier .Node est le package d'extension binaire de Node, voir le document officiel pour plus de détails). Le code ci-dessus est un exemple. Le nœud essaiera de trouver le fichier ./mymoduledir/index.js.
Au contraire, si le fichier package.json est trouvé, Node essaiera de l'analyser et de rechercher l'attribut principal dans la définition du package, puis d'utiliser 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:
La copie de code est la suivante:
{
"nom": "mymodule",
"Main": "./lib/mymodule.js"
}
Le nœud essaiera de charger le fichier ./mymoduledir/lib/mymodule.js
Chargement du répertoire Node_Modules
Si les paramètres de la fonction requise ne sont pas des chemins relatifs ou des noms de modules de base, le nœud sera recherché dans le sous-répertoire Node_Modules du répertoire actuel. Par exemple, dans le code suivant, Node essaiera de trouver le fichier./node_modules/mymodule.js:
La copie de code est la suivante:
var mymodule = requis ('mymodule.js');
Si cela n'est pas trouvé, Node continuera de rechercher dans le dossier Node_Modules du répertoire supérieur. Si cela n'est pas trouvé, continuez à rechercher dans le répertoire supérieur jusqu'à ce que le module correspondant soit trouvé ou que le répertoire racine soit 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 remettre les tâches de gestion des modules au NPM (voir chapitre 1). Le répertoire Node_Modules local est l'emplacement par défaut du module d'installation NPM. Cette conception associe le nœud et le NPM ensemble. Habituellement, en tant que développeur, vous n'avez pas à vous soucier trop de cette fonctionnalité. Vous pouvez simplement installer, mettre à jour et supprimer des packages à l'aide de NPM, ce qui vous aidera à maintenir le répertoire Node_Modules.
Module de cache
Le module sera mis en cache après le premier chargement réussi, c'est-à-dire si le nom du module est résolu dans le même chemin de fichier, chaque appel à exiger ('mymodule') renverra exactement le même module.
Par exemple, il existe un module appelé my_module.js qui contient le contenu suivant:
La copie de code est la suivante:
console.log ('module my_module Initializing ...');
module.exports = function () {
console.log («Hi!»);
};
console.log ('my_module initialisé.');
Utilisez ensuite le code suivant pour charger le module:
La copie de code est la suivante:
var mymoduleInstance1 = require ('./ my_module');
Il produit la sortie suivante:
La copie de code est la suivante:
Module My_Module Initialisation ...
my_module initialisé
Si nous l'importons deux fois:
La copie de code est la suivante:
var mymoduleInstance1 = require ('./ my_module');
var mymoduleInstance2 = require ('./ my_module');
La sortie est toujours:
La copie de code est la suivante:
Module My_Module Initialisation ...
my_module initialisé
C'est-à-dire que le code d'initialisation du module n'est exécuté qu'une seule fois. Lorsque vous créez votre propre module, si le code d'initialisation du module contient du code qui peut avoir des effets secondaires, vous devez accorder une attention particulière à cette fonctionnalité.
résumé
Le nœud a annulé la portée globale par défaut de JavaScript et a plutôt adopté le système de module CommonJS, afin que vous puissiez mieux organiser votre code et éviter de nombreux problèmes de sécurité et bogues. Vous pouvez utiliser la fonction Require pour charger des modules de base, des modules tiers ou charger vos propres modules à partir de fichiers et répertoires.
Vous pouvez également utiliser des chemins relatifs ou absolus pour charger des modules non essentiels. Si vous mettez 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 charger.
Note du traducteur:
Il est recommandé que les lecteurs lisent les chapitres du module du document officiel. Je pense personnellement que c'est plus clair que l'auteur. Un exemple très représentatif a été attaché, qui sera d'une grande aide pour comprendre le chargement du module de nœud. Ce qui suit est également cité:
La copie de code est la suivante:
Utiliser l'exigence (x) pour charger des modules sous le chemin y
1. Si x est le module de base,
un. Chargez et renvoyez le module de base
né Fin
2. Si x commence par './' ou '/' ou '../
un. Load_as_file (y + x)
né Load_as_directory (y + x)
3. Load_Node_Modules (x, dirname (y))
4. Jetez une exception: "Non trouvé"
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 comme un script javascript et se termine après le chargement
3. Si X.Node est un fichier, chargez X.Node en tant que plug-in binaire de nœud et terminez après le chargement.
Load_as_directory (x)
1. Si le fichier x / package.json existe,
un. Parses x / package.json et trouvez le champ "principal".
né Aussi m = x + (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 se termine après le chargement.
3. Si le fichier x / index.node existe, chargez x / index.Node en tant que plug-in binaire de nœud et fin après le chargement.
Load_node_modules (x, start)
1. Aussi dirs = node_modules_paths (start)
2. Faites les opérations suivantes pour chaque répertoire DIR sous DIRS:
un. Load_as_file (dir / x)
né Load_as_directory (dir / x)
Node_modules_paths (start)
1. Aussi parties = chemin à parcourir (démarrage)
2. Aussi root = index de la première instance de "node_modules" en parties, ou 0
3. Aussi i = nombre de pièces - 1
4. Aussi dirs = []
5. Pendant que je> root,
un. Si les pièces [i] = "node_modules"
c. Dir = chemin join (parties [0 .. i] + "node_modules")
né DIRS = DIRS + DIR
c. Aussi i = i - 1
6. Retour aux rédacteurs