Explication détaillée du chargement du module 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, à l'exception du fait que chaque script partage un espace de noms global.

Une fois qu'une page Web charge le code JavaScript, il sera injecté 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é, conflits et problèmes courants. ce qui rend les bugs à la fois difficiles à suivre et à 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.

Comprendre comment Node charge les modules

Dans Node, vous pouvez référencer des modules via des chemins de fichiers ou des noms de module. Si vous référencez un module non principal par son nom, Node fera finalement allusion au nom du module. . au chemin du 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 :

var module = require(‘module_name')

Ci-dessus Le code importera un module nommé module_name, qui peut être un module principal ou un module installé à l'aide de 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 d'exportation

Le système de modules CommonJS est le seul moyen de partager des objets et des fonctions entre des 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. À 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.

function Circle(x, y, r) {
       function r_squared() {
              return Math.pow(r, 2);
       }
       function area() {
              return Math.PI * r_squared();
       }
       return {area: area};
}
module.exports = Circle;

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 :

                  function printA() {
         console.log('A');
}
function printB() {
         console.log('B');
}
function 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 :

.

var myModule2 = require('./myModule2');
myModule2.printA(); // -> A
myModule2.printB(); // -> B
console.log(myModule2.pi); // -> 3.141592653589793

Chargement des modules

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 y en a. rien de tel dans Node. Le concept d'espace de noms global. Si le module existe et qu'il n'y a pas d'erreurs 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 différents, 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. Jetons un coup d'œil ci-dessous. Téléchargez ces connaissances.

Chargement des modules 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 par 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 principal http, vous pouvez faire ceci :

         var http = require('http');

Cela renverra un objet module http, qui contient le module http défini dans la documentation de l'API Node pour ces modules htpp.

Charger le module à partir du fichier

Vous pouvez également utiliser un chemin absolu pour charger le module à partir du système de fichiers :

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

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

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

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

注意上面的代码，你可以省略文件名的扩展名，如果Node找不到这个文件，会尝试在文件名后加上js后缀再次查找（译者注：其实除了js，还会查找json和node，具体可以看官网文档），因此，如果在当前目录下存在一个叫my_module.js的文件，会有下面两种加载方式：

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

加载目录模块

你还可以使用目录的路径来加载模块：

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

Node会假定这个目录是个模块包，并尝试在这个目录下搜索包定义文件package.json。

如果没找到，Node会假设包的入口点是index.js文件（译者注：除了index.js还会查找index.node，.node文件是Node的二进制扩展包，具体见官方文档），以上面代码为例，Node会尝试查找./myModuleDir/index.js文件。

反之，如果找到了package.json文件，Node会尝试解析它，并查找包定义里的main属性，然后把main属性的值当作入口点的相对路径。以本例来说，如果package.json定义如下：

                   {
                            "name" : "myModule",
                            "main" : "./lib/myModule.js"
                   }

Node就会尝试加载./myModuleDir/lib/myModule.js文件

从node_modules目录加载

如果require函数的参数不是相对路径，也不是核心模块名，Node会在当前目录的node_modules子目录下查找，比如下面的代码，Node会尝试查找文件./node_modules/myModule.js:

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

如果没找到，Node会继续在上级目录的node_modules文件夹下查找，如果还没找到就继续向上层目录查找，直到找到对应的模块或者到达根目录。

你可以使用这个特性来管理node_modules目录的内容或模块，不过最好还是把模块的管理任务交给NPM（见第一章），本地node_modules目录是NPM安装模块的默认位置，这个设计把Node和NPM关联在了一起。通常，作为开发人员不必太关心这个特性，你可以简单的使用NPM安装，更新和删除包，它会帮你维护node_modules目录

缓存模块

模块在第一次成功加载后会被缓存起来，就是说，如果模块名被解析到同一个文件路径，那么每次调用require(‘myModule')都确切地会返回同一个模块。

比如，有一个叫my_module.js的模块，包含下面的内容：

console.log('module my_module initializing...');
module.exports = function() {
         console.log('Hi!');
};
console.log('my_module initialized.');

然后用下面的代码加载这个模块：

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

它会产生下面的输出：

module my_module initializing...
my_module initialized

如果我们两次导入它：

var myModuleInstance1 = require('./my_module');
var myModuleInstance2 = require('./my_module');

如果我们两次导入它：

var myModuleInstance1 = require('./my_module');
var myModuleInstance2 = require('./my_module');

输出依然是：

module my_module initializing...
my_module initialized

也就是说，模块的初始化代码仅执行了一次。当你构建自己的模块时，如果模块的初始化代码里含有可能产生副作用的代码，一定要特别注意这个特性。

小结

Node取消了JavaScript的默认全局作用域，转而采用CommonJS模块系统，这样你可以更好的组织你的代码，也因此避免了很多安全问题和bug。可以使用require函数来加载核心模块，第三方模块，或从文件及目录加载你自己的模块

还可以用相对路径或者绝对路径来加载非核心模块，如果把模块放到了node_modules目录下或者对于用NPM安装的模块，你还可以直接使用模块名来加载。

 译者注：

建议读者把官方文档的模块章节阅读一遍，个人感觉比作者讲得更清晰明了，而且还附加了一个非常具有代表性的例子，对理解Node模块加载会很有很大帮助。下面把那个例子也引用过来：

用require(X) 加载路径Y下的模块
1. 如果X是核心模块,
   a. 加载并返回核心模块
   b. 结束
2. 如果X以 './' or '/' or '../ 开始'
   a. LOAD_AS_FILE(Y + X)
   b. LOAD_AS_DIRECTORY(Y + X)
3. LOAD_NODE_MODULES(X, dirname(Y))
4. 抛出异常："not found"
LOAD_AS_FILE(X)
1. 如果X是个文件，把 X作为JavaScript 脚本加载，加载完毕后结束
2. 如果X.js是个文件，把X.js 作为JavaScript 脚本加载，加载完毕后结束
3. 如果X.node是个文件，把X.node 作为Node二进制插件加载，加载完毕后结束
LOAD_AS_DIRECTORY(X)
1. 如果 X/package.json文件存在,
   a. 解析X/package.json, 并查找 "main"字段.
   b. 另M = X + (main字段的值)
   c. LOAD_AS_FILE(M)
2. 如果X/index.js文件存在，把 X/index.js作为JavaScript 脚本加载，加载完毕后结束
3. 如果X/index.node文件存在，把load X/index.node作为Node二进制插件加载，加载完毕后结束
LOAD_NODE_MODULES(X, START)
1. 另DIRS=NODE_MODULES_PATHS(START)
2. 对DIRS下的每个目录DIR做如下操作:
   a. LOAD_AS_FILE(DIR/X)
   b. LOAD_AS_DIRECTORY(DIR/X)
NODE_MODULES_PATHS(START)
1. 另PARTS = path split(START)
2. 另ROOT = index of first instance of "node_modules" in PARTS, or 0
3. 另I = count of PARTS - 1
4. 另DIRS = []
5. while I > ROOT,
   a. 如果 PARTS[I] = "node_modules" 则继续后续操作，否则下次循环
   c. DIR = path join(PARTS[0 .. I] + "node_modules")
   b. DIRS = DIRS + DIR
   c. 另I = I - 1
6. 返回DIRS

更多Node.js模块加载详解相关文章请关注PHP中文网！