穩(wěn)定性: 5 - 鎖定

Node 有簡(jiǎn)單的模塊加載系統(tǒng)。在 Node 里，文件和模塊是一一對(duì)應(yīng)的。下面例子里，foo.js 加載同一個(gè)文件夾里的 circle.js 模塊。

foo.js 內(nèi)容:

var circle = require('./circle.js');
console.log( 'The area of a circle of radius 4 is '
           + circle.area(4));

circle.js 內(nèi)容:

var PI = Math.PI;

exports.area = function (r) {
  return PI * r * r;
};

exports.circumference = function (r) {
  return 2 * PI * r;
};

circle.js 模塊輸出了 area() 和 circumference() 函數(shù)。想要給根模塊添加函數(shù)和對(duì)象，你可以將他們添加到特定的 exports 對(duì)象。

加載到模塊里的變量是私有的，仿佛模塊是包含在一個(gè)函數(shù)里。在這個(gè)例子里， PI 是 circle.js 的私有變量。

如果你想模塊里的根像一個(gè)函數(shù)一樣的輸出（比如 構(gòu)造函數(shù)），或者你想輸出一個(gè)完整對(duì)象,那就分派給 module.exports，而不是 exports。

bar.js 使用 square 模塊, 它輸出了構(gòu)造函數(shù):

var square = require('./square.js');
var mySquare = square(2);
console.log('The area of my square is ' + mySquare.area());

square 定義在 square.js 文件里:

// assigning to exports will not modify module, must use module.exports
module.exports = function(width) {
  return {
    area: function() {
      return width * width;
    }
  };
}

模塊系統(tǒng)在 require("module") 模塊里實(shí)現(xiàn)。

Cycles

環(huán)形調(diào)用 require() ，當(dāng)返回時(shí)模塊可能都沒執(zhí)行結(jié)束。

考慮以下場(chǎng)景:

a.js:

console.log('a starting');
exports.done = false;
var b = require('./b.js');
console.log('in a, b.done = %j', b.done);
exports.done = true;
console.log('a done');

b.js:

console.log('b starting');
exports.done = false;
var a = require('./a.js');
console.log('in b, a.done = %j', a.done);
exports.done = true;
console.log('b done');

main.js:

console.log('main starting');
var a = require('./a.js');
var b = require('./b.js');
console.log('in main, a.done=%j, b.done=%j', a.done, b.done);

當(dāng) main.js 加載 a.js，a.js加載 b.js。此時(shí)，b.js試著加載 a.js。為了阻止循環(huán)調(diào)用，a.js輸出對(duì)象的不完全拷貝返回給b.js 模塊。 b.js 會(huì)結(jié)束加載，并且它的exports 對(duì)象提供給 a.js 模塊。

main.js加載完兩個(gè)模塊時(shí)，它們都會(huì)結(jié)束。這個(gè)程序的輸出如下：

$ node main.js
main starting
a starting
b starting
in b, a.done = false
b done
in a, b.done = true
a done
in main, a.done=true, b.done=true

如果你的程序有環(huán)形模塊依賴，需要保證是線性的。

核心模塊

Node 有很多模塊編譯成二進(jìn)制。這些模塊在本文檔的其他地方有更詳細(xì)的描述。

核心模塊定義在 Node 的源代碼 lib/ 目錄里。

require() 總是會(huì)優(yōu)先加載核心模塊。例如，require('http') 總是返回編譯好的 HTTP 模塊，而不管這個(gè)文件的名字。

文件模塊

如果按照文件名沒有找到模塊，那么 Node 會(huì)試著加載添加了后綴 .js, .json 的文件，如果還沒好到，再試著加載添加了后綴.node 的文件。

.js 會(huì)解析為 JavaScript 的文本文件， .json 會(huì)解析為 JSON 文本文件，.node 會(huì)解析為編譯過的插件模塊，由 dlopen 負(fù)責(zé)加載。

模塊的前綴'/' 表示絕對(duì)路徑。例如 require('/home/marco/foo.js') 將會(huì)加載 /home/marco/foo.js文件。

模塊的前綴'./' 表示相對(duì)于調(diào)用 require()的路徑。就是說，circle.js必須和 foo.js 在 同一個(gè)目錄里，require('./circle') 才能找到。

文件前沒有 / 或 ./ 前綴，表示模塊可能是 core module，或者已經(jīng)從 node_modules 文件夾里加載過了。

如果指定的路徑不存在，require()將會(huì)拋出一個(gè) code 屬性為 'MODULE_NOT_FOUND' 的異常。

從 node_modules 目錄里加載

如傳遞給 require() 的模塊不是一個(gè)本地模塊，并且不以 '/', '../', 或 './' 開頭，那么 Node 會(huì)從當(dāng)前模塊的父目錄開始，嘗試在它的 node_modules 文件夾里加載模塊。

如果沒有找到，那么會(huì)到父目錄，直到到文件系統(tǒng)的根目錄里找。

例如，如果 '/home/ry/projects/foo.js' 里的文件加載 require('bar.js')，那么 Node 將會(huì)按照下面的順序查找:

• /home/ry/projects/node_modules/bar.js
• /home/ry/node_modules/bar.js
• /home/node_modules/bar.js
• /node_modules/bar.js

這樣允許程序獨(dú)立，不會(huì)產(chǎn)生沖突。

可以請(qǐng)求指定的文件或分布子目錄里的模塊，在模塊名后添加路徑后綴。例如，require('example-module/path/to/file') 會(huì)解決 path/to/file 相對(duì)于example-module 的加載位置。路徑后綴使用相同語法。

文件夾作為模塊

可以把程序和庫(kù)放到獨(dú)立的文件夾里，并提供單一的入口指向他們。有三種方法可以將文件夾作為參數(shù)傳給 require() 。

第一個(gè)方法是，在文件夾的根創(chuàng)建一個(gè) package.json 文件，它指定了 main 模塊。package.json 的例子如下：

{ "name" : "some-library",
  "main" : "./lib/some-library.js" }

如果這是在 ./some-library 里的文件夾，require('./some-library') 將會(huì)試著加載 ./some-library/lib/some-library.js。

如果文件夾里沒有 package.json 文件，Node 會(huì)試著加載 index.js 或 index.node 文件。例如，如果上面的例子里沒有 package.json 文件。那么 require('./some-library') 將會(huì)試著加載：

• ./some-library/index.js
• ./some-library/index.node

緩存

模塊第一次加載后會(huì)被被緩存。這就是說，每次調(diào)用 require('foo') 都會(huì)返回同一個(gè)對(duì)象，當(dāng)然，必須每次都要解析到同一個(gè)文件。

多次調(diào)用 require('foo') 也許不會(huì)導(dǎo)致模塊代碼多次執(zhí)行。這是很重要的特性，這樣就可以返回 "partially done" 對(duì)象，允許加載過渡性的依賴關(guān)系，即使可能會(huì)引起環(huán)形調(diào)用。

如果你希望多次調(diào)用一個(gè)模塊，那么就輸出一個(gè)函數(shù)，然后調(diào)用這個(gè)函數(shù)。

模塊換成預(yù)警

模塊的緩存依賴于解析后的文件名。因此隨著調(diào)用位置的不同，模塊可能解析到不同的文件（例如，從 node_modules 文件夾加載）。如果解析為不同的文件，require('foo') 可能會(huì)返回不同的對(duì)象。

module 對(duì)象

• {Object}

在每個(gè)模塊中，變量 module 是一個(gè)代表當(dāng)前模塊的對(duì)象的引用。為了方便，module.exports 可以通過 exports 全局模塊訪問。module 不是事實(shí)上的全局對(duì)象，而是每個(gè)模塊內(nèi)部的。

module.exports

• {Object}

模塊系統(tǒng)創(chuàng)建 module.exports 對(duì)象。很多人希望自己的模塊是某個(gè)類的實(shí)例。因此，把將要導(dǎo)出的對(duì)象賦值給 module.exports。注意，將想要的對(duì)象賦值給 exports ，只是簡(jiǎn)單的將它綁定到本地 exports 變量，這可能并不是你想要的。

例如，假設(shè)我們有一個(gè)模塊叫 a.js。

var EventEmitter = require('events').EventEmitter;

module.exports = new EventEmitter();

// Do some work, and after some time emit
// the 'ready' event from the module itself.
setTimeout(function() {
  module.exports.emit('ready');
}, 1000);

另一個(gè)文件可以這么寫：

var a = require('./a');
a.on('ready', function() {
  console.log('module a is ready');
});

注意，賦給 module.exports 必須馬上執(zhí)行，并且不能在回調(diào)中執(zhí)行。

x.js:

setTimeout(function() {
  module.exports = { a: "hello" };
}, 0);

y.js:

var x = require('./x');
console.log(x.a);

exports alias

exports 變量在引用到 module.exports 的模塊里可用。和其他變量一樣，如果你給他賦一個(gè)新的值，它不再指向老的值。

為了展示這個(gè)特性，假設(shè)實(shí)現(xiàn)： require():

function require(...) {
  // ...
  function (module, exports) {
    // Your module code here
    exports = some_func;        // re-assigns exports, exports is no longer
                                // a shortcut, and nothing is exported.
    module.exports = some_func; // makes your module export 0
  } (module, module.exports);
  return module;
}

如果你對(duì) exports 和 module.exports 間的關(guān)系感到迷糊，那就只用module.exports 就好。

module.require(id)

• id {String}
• 返回: {Object} 已經(jīng)解析模塊的module.exports

module.require 方法提供了一種像 require() 一樣從最初的模塊加載一個(gè)模塊的方法。

為了能這樣做，你必須獲得module 對(duì)象的引用。require() 返回 module.exports，并且 module 是一個(gè)典型的只能在特定模塊作用域內(nèi)有效的變量，如果要使用它，就必須明確的導(dǎo)出。

module.id

• {String}

模塊的標(biāo)識(shí)符。通常是完全解析的文件名。

module.filename

• {String}

模塊完全解析的文件名。

module.loaded

• {Boolean}

模塊是已經(jīng)加載完畢，還是在加載中。

module.parent

• {Module Object}

引入這個(gè)模塊的模塊。

module.children

• {Array}

由這個(gè)模塊引入的模塊。

其他...

為了獲取即將用 require() 加載的準(zhǔn)確文件名，可以使用 require.resolve() 函數(shù)。

綜上所述，下面用偽代碼的高級(jí)算法形式演示了 require.resolve 的工作流程：

require(X) from module at path Y
1. If X is a core module,
   a. return the core module
   b. STOP
2. If X begins with './' or '/' or '../'
   a. LOAD_AS_FILE(Y + X)
   b. LOAD_AS_DIRECTORY(Y + X)
3. LOAD_NODE_MODULES(X, dirname(Y))
4. THROW "not found"

LOAD_AS_FILE(X)
1. If X is a file, load X as JavaScript text.  STOP
2. If X.js is a file, load X.js as JavaScript text.  STOP
3. If X.json is a file, parse X.json to a JavaScript Object.  STOP
4. If X.node is a file, load X.node as binary addon.  STOP

LOAD_AS_DIRECTORY(X)
1. If X/package.json is a file,
   a. Parse X/package.json, and look for "main" field.
   b. let M = X + (json main field)
   c. LOAD_AS_FILE(M)
2. If X/index.js is a file, load X/index.js as JavaScript text.  STOP
3. If X/index.json is a file, parse X/index.json to a JavaScript object. STOP
4. If X/index.node is a file, load X/index.node as binary addon.  STOP

LOAD_NODE_MODULES(X, START)
1. let DIRS=NODE_MODULES_PATHS(START)
2. for each DIR in DIRS:
   a. LOAD_AS_FILE(DIR/X)
   b. LOAD_AS_DIRECTORY(DIR/X)

NODE_MODULES_PATHS(START)
1. let PARTS = path split(START)
2. let I = count of PARTS - 1
3. let DIRS = []
4. while I >= 0,
   a. if PARTS[I] = "node_modules" CONTINUE
   c. DIR = path join(PARTS[0 .. I] + "node_modules")
   b. DIRS = DIRS + DIR
   c. let I = I - 1
5. return DIRS

從全局文件夾加載

如果環(huán)境變量 NODE_PATH 設(shè)置為冒號(hào)分割的絕對(duì)路徑列表，并且在模塊在其他地方?jīng)]有找到，Node 將會(huì)搜索這些路徑。（注意，Windows 里，NODE_PATH用分號(hào)分割 ）。

另外， Node 將會(huì)搜索這些路徑。

• 1: $HOME/.node_modules
• 2: $HOME/.node_libraries
• 3: $PREFIX/lib/node

$HOME 是用戶的 home 文件夾，$PREFIX 是 Node 里配置的 node_prefix。

這大多是歷史原因照成的。強(qiáng)烈建議將所以來的模塊放到 node_modules 文件夾里。這樣加載會(huì)更快。

訪問主模塊

當(dāng) Node 運(yùn)行一個(gè)文件時(shí)， require.main 就會(huì)設(shè)置為它的 module。也就是說你可以通過測(cè)試判斷文件是否被直接運(yùn)行。

require.main === module

對(duì)于 foo.js 文件。 如果直接運(yùn)行 node foo.js，返回 true， 如果通過 require('./foo')是間接運(yùn)行。

因?yàn)?module 提供了 filename 屬性（通常等于__filename），程序的入口點(diǎn)可以通過檢查 require.main.filename 來獲得。

附錄: 包管理技巧

Node 的 require() 函數(shù)語義定義的足夠通用，它能支持各種常規(guī)目錄結(jié)構(gòu)。諸如 dpkg, rpm, 和 npm 包管理程序，不用修改就可以從 Node 模塊構(gòu)建本地包。

下面我們介紹一個(gè)可行的目錄結(jié)構(gòu)：

假設(shè)我們有一個(gè)文件夾 /usr/lib/node/<some-package>/<some-version>，包含指定版本的包內(nèi)容。

一個(gè)包可以依賴于其他包。為了安裝包 foo，可能需要安裝特定版本的 bar 包。 bar 包可能有自己的包依賴，某些條件下，依賴關(guān)系可能會(huì)發(fā)生沖突或形成循環(huán)。

因?yàn)?Node 會(huì)查找他所加載的模塊的 realpath（也就是說會(huì)解析符號(hào)鏈接），然后按照上文描述的方式在 node_modules 目錄中尋找依賴關(guān)系，這種情形跟以下體系結(jié)構(gòu)非常相像：

• /usr/lib/node/foo/1.2.3/ - foo 包, version 1.2.3.
• /usr/lib/node/bar/4.3.2/ - foo 依賴的 bar 包內(nèi)容
• /usr/lib/node/foo/1.2.3/node_modules/bar - 指向 /usr/lib/node/bar/4.3.2/ 的符號(hào)鏈接
• /usr/lib/node/bar/4.3.2/node_modules/* - 指向 bar 包所依賴的包的符號(hào)鏈接

因此，即使存在循環(huán)依賴或依賴沖突，每個(gè)模塊還可以獲得他所依賴的包得可用版本。

當(dāng)foo 包里的代碼調(diào)用 foo ，將會(huì)獲得符號(hào)鏈接/usr/lib/node/foo/1.2.3/node_modules/bar 指向的版本。然后，當(dāng) bar 包中的代碼調(diào)用 require('queue')，將會(huì)獲得符號(hào)鏈接 /usr/lib/node/bar/4.3.2/node_modules/quux 指向的版本。

另外，為了讓模塊搜索更快些，不要將包直接放在 /usr/lib/node 目錄中，而是將它們放在 /usr/lib/node_modules/<name>/<version> 目錄中。 這樣在依賴的包找不到的情況下，就不會(huì)一直尋找 /usr/node_modules 目錄或 /node_modules 目錄了?；谡{(diào)用 require() 的文件所在真實(shí)路徑，因此包本身可以放在任何位置。

為了讓 Node 模塊對(duì) Node REPL 可用，可能需要將 /usr/lib/node_modules 文件夾路徑添加到環(huán)境變量 $NODE_PATH 。由于模塊查找 $NODE_PATH 文件夾都是相對(duì)路徑，因此包可以放到任何位置。