本文實(shí)例講述了Node.js API詳解之 module模塊用法。分享給大家供大家參考，具體如下：

Node.js API詳解之 module

Node.js 有一個(gè)簡(jiǎn)單的模塊加載系統(tǒng)。

在 Node.js 中，文件和模塊是一一對(duì)應(yīng)的（每個(gè)文件被視為一個(gè)獨(dú)立的模塊）。

例子，假設(shè)有一個(gè)名為 foo.js 的文件：

const circle = require('./circle.js');
console.log(`半徑為 4 的圓的面積是 ${circle.area(4)}`);

在第一行中，foo.js 加載了同一目錄下的 circle.js 模塊。

circle.js 文件的內(nèi)容為：

const { PI } = Math;
exports.area = (r) => PI * r ** 2;
exports.circumference = (r) => 2 * PI * r;

circle.js 模塊導(dǎo)出了 area() 和 circumference() 兩個(gè)函數(shù)。

通過(guò)在特殊的 exports 對(duì)象上指定額外的屬性，函數(shù)和對(duì)象可以被添加到模塊的根部。

模塊內(nèi)的本地變量是私有的，因?yàn)槟K被 Node.js 包裝在一個(gè)函數(shù)中（詳見(jiàn)模塊包裝器）。

在這個(gè)例子中，變量 PI 是 circle.js 私有的。

module.exports 屬性可以被賦予一個(gè)新的值（例如函數(shù)或?qū)ο螅?/p>

如下，bar.js 會(huì)用到 square 模塊，square 導(dǎo)出一個(gè)構(gòu)造函數(shù)：

const square = require('./square.js');
const mySquare = square(2);
console.log(`正方形的面積是 ${mySquare.area()}`);

square 模塊定義在 square.js 中：

// 賦值給 `exports` 不會(huì)修改模塊，必須使用 `module.exports`
module.exports = (width) => {
 return {
  area: () => width ** 2
 };
};

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

模塊包裝器

說(shuō)明：

在執(zhí)行模塊代碼之前，Node.js 會(huì)使用一個(gè)如下的函數(shù)包裝器將其包裝：

(function(exports, require, module, __filename, __dirname) {
// 模塊的代碼實(shí)際上在這里
});

通過(guò)這樣做，Node.js 實(shí)現(xiàn)了以下幾點(diǎn)：
它保持了頂層的變量（用 var、const 或 let 定義）作用在模塊范圍內(nèi)，而不是全局對(duì)象。
它有助于提供一些看似全局的但實(shí)際上是模塊特定的變量，例如：
實(shí)現(xiàn)者可以用于從模塊中導(dǎo)出值的 module 和 exports 對(duì)象。
包含模塊絕對(duì)文件名和目錄路徑的快捷變量 __filename 和 __dirname 。

文件模塊

說(shuō)明：

如果按確切的文件名沒(méi)有找到模塊，則 Node.js 會(huì)嘗試帶上 .js、.json 或 .node 拓展名再加載。
.js 文件會(huì)被解析為 JavaScript 文本文件，
.json 文件會(huì)被解析為 JSON 文本文件。
.node 文件會(huì)被解析為通過(guò) dlopen 加載的編譯后的插件模塊。
以 ‘/' 為前綴的模塊是文件的絕對(duì)路徑。 例如，require(‘/home/marco/foo.js') 會(huì)加載 /home/marco/foo.js 文件。
以 ‘./' 為前綴的模塊是相對(duì)于調(diào)用 require() 的文件的。 也就是說(shuō)，circle.js 必須和 foo.js 在同一目錄下以便于 require(‘./circle') 找到它。
當(dāng)沒(méi)有以 ‘/'、'./' 或 ‘../' 開(kāi)頭來(lái)表示文件時(shí)，這個(gè)模塊必須是一個(gè)核心模塊或加載自 node_modules 目錄。
如果給定的路徑不存在，則 require() 會(huì)拋出一個(gè) code 屬性為 ‘MODULE_NOT_FOUND' 的 Error。

目錄作為模塊

說(shuō)明：

可以把程序和庫(kù)放到一個(gè)單獨(dú)的目錄，然后提供一個(gè)單一的入口來(lái)指向它。
把目錄遞給 require() 作為一個(gè)參數(shù)，有三種方式。
第一種方式是在根目錄下創(chuàng)建一個(gè) package.json 文件，并指定一個(gè) main 模塊。

例子，package.json 文件類似：

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

如果這是在 ./some-library 目錄中，則 require(‘./some-library') 會(huì)試圖加載 ./some-library/lib/some-library.js。
這就是 Node.js 處理 package.json 文件的方式。
注意：如果 package.json 中 “main” 入口指定的文件不存在，則無(wú)法解析，Node.js 會(huì)將模塊視為不存在，并拋出默認(rèn)錯(cuò)誤:

Error: Cannot find module 'some-library'

如果目錄里沒(méi)有 package.json 文件，則 Node.js 就會(huì)試圖加載目錄下的 index.js 或 index.node 文件。
例如，如果上面的例子中沒(méi)有 package.json 文件，則 require(‘./some-library') 會(huì)試圖加載：
./some-library/index.js
./some-library/index.node

模塊加載順序

說(shuō)明：

如果傳遞給 require() 的模塊標(biāo)識(shí)符不是一個(gè)核心模塊，也沒(méi)有以 ‘/' 、 ‘../' 或 ‘./' 開(kāi)頭，
則 Node.js 會(huì)從當(dāng)前模塊的父目錄開(kāi)始，嘗試從它的 /node_modules 目錄里加載模塊。
Node.js 不會(huì)附加 node_modules 到一個(gè)已經(jīng)以 node_modules 結(jié)尾的路徑上。
如果還是沒(méi)有找到，則移動(dòng)到再上一層父目錄，直到文件系統(tǒng)的根目錄。
例子，如果在 ‘/home/ry/projects/foo.js' 文件里調(diào)用了 require(‘bar.js')，則 Node.js 會(huì)按以下順序查找：
/home/ry/projects/node_modules/bar.js
/home/ry/node_modules/bar.js
/home/node_modules/bar.js
/node_modules/bar.js
通過(guò)在模塊名后包含一個(gè)路徑后綴，可以請(qǐng)求特定的文件或分布式的子模塊。
例如，require(‘example-module/path/to/file') 會(huì)把 path/to/file 解析成相對(duì)于 example-module 的位置。
后綴路徑同樣遵循模塊的解析語(yǔ)法。

從全局目錄加載

說(shuō)明：

如果 NODE_PATH 環(huán)境變量被設(shè)為一個(gè)以冒號(hào)分割的絕對(duì)路徑列表，則當(dāng)在其他地方找不到模塊時(shí) Node.js 會(huì)搜索這些路徑。
注意：在 Windows 系統(tǒng)中，NODE_PATH 是以分號(hào)間隔的。
在當(dāng)前的模塊解析算法運(yùn)行之前，NODE_PATH 最初是創(chuàng)建來(lái)支持從不同路徑加載模塊的。
雖然 NODE_PATH 仍然被支持，但現(xiàn)在不太需要，因?yàn)?Node.js 生態(tài)系統(tǒng)已制定了一套存放依賴模塊的約定。
有時(shí)當(dāng)人們沒(méi)意識(shí)到 NODE_PATH 必須被設(shè)置時(shí)，依賴 NODE_PATH 的部署會(huì)出現(xiàn)意料之外的行為。
有時(shí)一個(gè)模塊的依賴會(huì)改變，導(dǎo)致在搜索 NODE_PATH 時(shí)加載了不同的版本（甚至不同的模塊）。
此外，Node.js 還會(huì)搜索以下位置：
1: $HOME/.node_modules
2: $HOME/.node_libraries
3: $PREFIX/lib/node
其中 $HOME 是用戶的主目錄，$PREFIX 是 Node.js 里配置的 node_prefix。
這些主要是歷史原因。
注意：強(qiáng)烈建議將所有的依賴放在本地的 node_modules 目錄。 這樣將會(huì)更快地加載，且更可靠。

緩存

說(shuō)明：

模塊在第一次加載后會(huì)被緩存。 這也意味著（類似其他緩存機(jī)制）如果每次調(diào)用 require(‘foo') 都解析到同一文件，則返回相同的對(duì)象。
多次調(diào)用 require(foo) 不會(huì)導(dǎo)致模塊的代碼被執(zhí)行多次。 這是一個(gè)重要的特性。
借助它, 可以返回“部分完成”的對(duì)象，從而允許加載依賴的依賴, 即使它們會(huì)導(dǎo)致循環(huán)依賴。
如果想要多次執(zhí)行一個(gè)模塊，可以導(dǎo)出一個(gè)函數(shù)，然后調(diào)用該函數(shù)。
注意：
模塊是基于其解析的文件名進(jìn)行緩存的。 由于調(diào)用模塊的位置的不同，模塊可能被解析成不同的文件名（比如從 node_modules 目錄加載），
這樣就不能保證 require(‘foo') 總能返回完全相同的對(duì)象。
此外，在不區(qū)分大小寫(xiě)的文件系統(tǒng)或操作系統(tǒng)中，被解析成不同的文件名可以指向同一文件，但緩存仍然會(huì)將它們視為不同的模塊，并多次重新加載。
例如，require(‘./foo') 和 require(‘./FOO') 返回兩個(gè)不同的對(duì)象，而不會(huì)管 ./foo 和 ./FOO 是否是相同的文件。

循環(huán)

說(shuō)明：

當(dāng)循環(huán)調(diào)用 require() 時(shí)，一個(gè)模塊可能在未完成執(zhí)行時(shí)被返回。

例如以下情況:
a.js:

console.log('a 開(kāi)始');
 exports.done = false;
 const b = require('./b.js');
 console.log('在 a 中，b.done = %j', b.done);
 exports.done = true;
 console.log('a 結(jié)束');

b.js:

console.log('b 開(kāi)始');
 exports.done = false;
 const a = require('./a.js');
 console.log('在 b 中，a.done = %j', a.done);
 exports.done = true;
 console.log('b 結(jié)束');

main.js:

console.log('main 開(kāi)始');
 const a = require('./a.js');
 const b = require('./b.js');
 console.log('在 main 中，a.done=%j，b.done=%j', a.done, b.done);

當(dāng) main.js 加載 a.js 時(shí)，a.js 又加載 b.js。
此時(shí)，b.js 會(huì)嘗試去加載 a.js。
為了防止無(wú)限的循環(huán)，會(huì)返回一個(gè) a.js 的 exports 對(duì)象的 未完成的副本 給 b.js 模塊。
然后 b.js 完成加載，并將 exports 對(duì)象提供給 a.js 模塊。
當(dāng) main.js 加載這兩個(gè)模塊時(shí)，它們都已經(jīng)完成加載。 因此，該程序的輸出會(huì)是：

$ node main.js
 main 開(kāi)始
 a 開(kāi)始
 b 開(kāi)始
 在 b 中，a.done = false
 b 結(jié)束
 在 a 中，b.done = true
 a 結(jié)束
 在 main 中，a.done=true，b.done=true

__dirname

說(shuō)明：

當(dāng)前模塊的文件夾名稱。等同于 __filename 的 path.dirname() 的值。

demo：

console.log(__dirname);
// /Users/xiaoqiang/Documents/work/demo/NodeApi

__filename

說(shuō)明：

當(dāng)前模塊的文件名稱—解析后的絕對(duì)路徑。
在主程序中這不一定要跟命令行中使用的名稱一致。

demo：

console.log(__filename);
// /Users/xiaoqiang/Documents/work/demo/NodeApi/app.js

module.exports

說(shuō)明：

module.exports 對(duì)象是由模塊系統(tǒng)創(chuàng)建的。
有時(shí)這是難以接受的；許多人希望他們的模塊成為某個(gè)類的實(shí)例。
為了實(shí)現(xiàn)這個(gè)，需要將期望導(dǎo)出的對(duì)象賦值給 module.exports。
注意，將期望的對(duì)象賦值給 exports 會(huì)簡(jiǎn)單地重新綁定本地 exports 變量，這可能不是期望的。
注意，對(duì) module.exports 的賦值必須立即完成。 不能在任何回調(diào)中完成。

demo：

// a.js
const EventEmitter = require('events');
module.exports = new EventEmitter();
// app.js
const a = require('./a');
a.on('ready', () => {
  console.log('模塊 a 已準(zhǔn)備好');
});

exports

說(shuō)明：

這是一個(gè)對(duì)于 module.exports 的更簡(jiǎn)短的引用形式。
exports 變量是在模塊的文件級(jí)別作用域內(nèi)有效的，它在模塊被執(zhí)行前被賦予 module.exports 的值。
它有一個(gè)快捷方式，以便 module.exports.f = …
可以被更簡(jiǎn)潔地寫(xiě)成 exports.f = …。
注意，就像任何變量，如果一個(gè)新的值被賦值給 exports，它就不再綁定到 module.exports：

demo：

// a.js
const EventEmitter = require('events');
exports.events = new EventEmitter();
// app.js
const {events} = require('./a');
events.on('ready', () => {
  console.log('模塊 a 已準(zhǔn)備好');
});

require()

說(shuō)明：

使用該方法引入模塊。

demo：

const {events} = require('./a');
events.on('ready', () => {
  console.log('模塊 a 已準(zhǔn)備好');
});

require.main

說(shuō)明：

當(dāng) Node.js 直接運(yùn)行一個(gè)文件時(shí)，require.main 會(huì)被設(shè)為它的 module。
這意味著可以通過(guò) require.main === module 來(lái)判斷一個(gè)文件是否被直接運(yùn)行：
對(duì)于 foo.js 文件，如果通過(guò) node foo.js 運(yùn)行則為 true，但如果通過(guò) require(‘./foo') 運(yùn)行則為 false。
因?yàn)?module 提供了一個(gè) filename 屬性（通常等同于 __filename），
所以可以通過(guò)檢查 require.main.filename 來(lái)獲取當(dāng)前應(yīng)用程序的入口點(diǎn)。

demo：

const events = require('./a');
console.log(require.main);
// Module {
//  id: '.',
//  exports: {},
//  parent: null,
//  filename: '/Users/xiaoqiang/Documents/work/demo/NodeApi/app.js',
//  loaded: false,
//  children:
//  [ Module {
//    id: '/Users/xiaoqiang/Documents/work/demo/NodeApi/a.js',
//    exports: [Object],
//    parent: [Circular],
//    filename: '/Users/xiaoqiang/Documents/work/demo/NodeApi/a.js',
//    loaded: true,
//    children: [],
//    paths: [Array] } ],
//  paths:
//  [ '/Users/xiaoqiang/Documents/work/demo/NodeApi/node_modules',
//   '/Users/xiaoqiang/Documents/work/demo/node_modules',
//   '/Users/xiaoqiang/Documents/work/node_modules',
//   '/Users/xiaoqiang/Documents/node_modules',
//   '/Users/xiaoqiang/node_modules',
//   '/Users/node_modules',
//   '/node_modules' ] 
// }

require.cache

說(shuō)明：

被引入的模塊將被緩存在這個(gè)對(duì)象中。
從此對(duì)象中刪除鍵值對(duì)將會(huì)導(dǎo)致下一次 require 重新加載被刪除的模塊。
注意不能刪除 native addons（原生插件），因?yàn)樗鼈兊闹剌d將會(huì)導(dǎo)致錯(cuò)誤。

demo：

const events = require('./a');
console.log(require.cache);
// { '/Users/xiaoqiang/Documents/work/demo/NodeApi/app.js':
//  Module {
//   id: '.',
//   exports: {},
//   parent: null,
//   filename: '/Users/xiaoqiang/Documents/work/demo/NodeApi/app.js',
//   loaded: false,
//   children: [ [Module] ],
//   paths:
//    [ '/Users/xiaoqiang/Documents/work/demo/NodeApi/node_modules',
//     '/Users/xiaoqiang/Documents/work/demo/node_modules',
//     '/Users/xiaoqiang/Documents/work/node_modules',
//     '/Users/xiaoqiang/Documents/node_modules',
//     '/Users/xiaoqiang/node_modules',
//     '/Users/node_modules',
//     '/node_modules' ] },
//  '/Users/xiaoqiang/Documents/work/demo/NodeApi/a.js':
//  Module {
//   id: '/Users/xiaoqiang/Documents/work/demo/NodeApi/a.js',
//   exports: { events: [EventEmitter] },
//   parent:
//    Module {
//     id: '.',
//     exports: {},
//     parent: null,
//     filename: '/Users/xiaoqiang/Documents/work/demo/NodeApi/app.js',
//     loaded: false,
//     children: [Array],
//     paths: [Array] },
//   filename: '/Users/xiaoqiang/Documents/work/demo/NodeApi/a.js',
//   loaded: true,
//   children: [],
//   paths:
//    [ '/Users/xiaoqiang/Documents/work/demo/NodeApi/node_modules',
//     '/Users/xiaoqiang/Documents/work/demo/node_modules',
//     '/Users/xiaoqiang/Documents/work/node_modules',
//     '/Users/xiaoqiang/Documents/node_modules',
//     '/Users/xiaoqiang/node_modules',
//     '/Users/node_modules',
//     '/node_modules' ] 
//   } 
// }

require.extensions (已廢棄)

說(shuō)明：

指示 require 怎樣處理特定的文件擴(kuò)展名。
以前這被用來(lái)將非 JavaScript 模塊按需編譯后加載到 Node.js 中。
然而，在實(shí)踐中，有更多更好的解決方案，比如用其它 Node.js 程序加載模塊， 或者提前將它們編譯為 JavaScript 模塊。
由于模塊系統(tǒng)已鎖定，這個(gè)特性可能永遠(yuǎn)不會(huì)消失，但是鑒于其復(fù)雜性和可能導(dǎo)致的小問(wèn)題， 最好不要碰它。
例如：把 .sjs 文件當(dāng)做 .js 文件處理：

demo：

require.extensions['.sjs'] = require.extensions['.js'];

require.resolve(request[, options])

說(shuō)明：

使用內(nèi)部的 require() 機(jī)制查詢模塊的位置, 此操作只返回解析后的文件名，不會(huì)加載該模塊。
request：需要解析的模塊路徑。
options.paths:解析模塊的起點(diǎn)路徑數(shù)組。此參數(shù)存在時(shí)，將使用這些路徑而非默認(rèn)解析路徑。

demo：

const events = require('./a');
console.log( require.resolve('./a') );
// /Users/xiaoqiang/Documents/work/demo/NodeApi/a.js

require.resolve.paths(request)

說(shuō)明：

返回一個(gè)數(shù)組，其中包含解析 request 過(guò)程中被查詢的路徑。
request：被查詢解析路徑的模塊的路徑。

demo：

const events = require('./a');
console.log( require.resolve.paths('./a') );
// [ '/Users/xiaoqiang/Documents/work/demo/NodeApi' ]

module

說(shuō)明：

返回對(duì)當(dāng)前模塊的引用，是一個(gè)module對(duì)象。

demo：

const events = require('./a');
console.log( module );
// Module {
//  id: '.',
//  exports: {},
//  parent: null,
//  filename: '/Users/xiaoqiang/Documents/work/demo/NodeApi/app.js',
//  loaded: false,
//  children:
//  [ Module {
//    id: '/Users/xiaoqiang/Documents/work/demo/NodeApi/a.js',
//    exports: [Object],
//    parent: [Circular],
//    filename: '/Users/xiaoqiang/Documents/work/demo/NodeApi/a.js',
//    loaded: true,
//    children: [],
//    paths: [Array] } ],
//  paths:
//  [ '/Users/xiaoqiang/Documents/work/demo/NodeApi/node_modules',
//   '/Users/xiaoqiang/Documents/work/demo/node_modules',
//   '/Users/xiaoqiang/Documents/work/node_modules',
//   '/Users/xiaoqiang/Documents/node_modules',
//   '/Users/xiaoqiang/node_modules',
//   '/Users/node_modules',
//   '/node_modules' ] 
// }

module 對(duì)象

說(shuō)明：

在每個(gè)模塊中，module 的自由變量是一個(gè)指向表示當(dāng)前模塊的對(duì)象的引用。
為了方便，module.exports 也可以通過(guò)全局模塊的 exports 對(duì)象訪問(wèn)。
module 實(shí)際上不是全局的，而是每個(gè)模塊本地的。

module.id

說(shuō)明：

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

demo：

const events = require('events');
console.log( module.id );
// .

module.parent

說(shuō)明：

最先引用該模塊的模塊。

demo：

const events= require('events');
console.log( module.parent );
// null

module.children

說(shuō)明：

返回被該模塊引用的模塊對(duì)象。

demo：

const events = require('events');
console.log( module.children );
// []

module.filename

說(shuō)明：

返回模塊的完全解析后的文件名。

demo：

const events = require('events');
console.log( module.filename );
// /Users/xiaoqiang/Documents/work/demo/NodeApi/app.js

module.loaded

說(shuō)明：

返回模塊是否已經(jīng)加載完成，或正在加載中。

demo：

const events = require('events');
console.log( module.loaded );
// false

module.paths

說(shuō)明：

返回模塊的搜索路徑。

demo：

const events = require('events');
console.log( module.paths );
// [ '/Users/xiaoqiang/Documents/work/demo/NodeApi/node_modules',
//  '/Users/xiaoqiang/Documents/work/demo/node_modules',
//  '/Users/xiaoqiang/Documents/work/node_modules',
//  '/Users/xiaoqiang/Documents/node_modules',
//  '/Users/xiaoqiang/node_modules',
//  '/Users/node_modules',
//  '/node_modules' ]

希望本文所述對(duì)大家node.js程序設(shè)計(jì)有所幫助。

最新評(píng)論