Node.js CommonJS規(guī)范

2021-09-15 16:25 更新

概述

CommonJS是服務(wù)器模塊的規(guī)范，Node.js采用了這個(gè)規(guī)范。

根據(jù)CommonJS規(guī)范，一個(gè)單獨(dú)的文件就是一個(gè)模塊。每一個(gè)模塊都是一個(gè)單獨(dú)的作用域，也就是說(shuō)，在一個(gè)文件定義的變量（還包括函數(shù)和類），都是私有的，對(duì)其他文件是不可見(jiàn)的。

var x = 5;
var addX = function(value) {
  return value + x;
};

上面代碼中，變量x和函數(shù)addX，是當(dāng)前文件私有的，其他文件不可見(jiàn)。

如果想在多個(gè)文件分享變量，必須定義為global對(duì)象的屬性。

global.warning = true;

上面代碼的waining變量，可以被所有文件讀取。當(dāng)然，這樣寫法是不推薦的。

CommonJS規(guī)定，每個(gè)文件的對(duì)外接口是module.exports對(duì)象。這個(gè)對(duì)象的所有屬性和方法，都可以被其他文件導(dǎo)入。

var x = 5;
var addX = function(value) {
  return value + x;
};
module.exports.x = x;
module.exports.addX = addX;

上面代碼通過(guò)module.exports對(duì)象，定義對(duì)外接口，輸出變量x和函數(shù)addX。module.exports對(duì)象是可以被其他文件導(dǎo)入的，它其實(shí)就是文件內(nèi)部與外部通信的橋梁。

require方法用于在其他文件加載這個(gè)接口，具體用法參見(jiàn)《Require命令》的部分。

var example = require('./example.js');

console.log(example.x); // 5
console.log(addX(1)); // 6

module對(duì)象

每個(gè)模塊都有一個(gè)module變量，該變量指向當(dāng)前模塊。module不是全局變量，而是每個(gè)模塊都有的本地變量。

  • module.id 模塊的識(shí)別符，通常是帶有絕對(duì)路徑的模塊文件名。
  • module.filename 模塊的文件名。
  • module.loaded 返回一個(gè)布爾值，表示模塊是否已經(jīng)完成加載。
  • module.parent 返回一個(gè)對(duì)象，表示調(diào)用該模塊的模塊。
  • module.children 返回一個(gè)數(shù)組，表示該模塊要用到的其他模塊。

下面是一個(gè)示例文件，最后一行輸出module變量。

// example.js
var jquery = require('jquery');
exports.$ = jquery;
console.log(module);

執(zhí)行這個(gè)文件，命令行會(huì)輸出如下信息。

{ id: '.',
  exports: { '/div>: [Function] },
  parent: null,
  filename: '/path/to/example.js',
  loaded: false,
  children:
   [ { id: '/path/to/node_modules/jquery/dist/jquery.js',
       exports: [Function],
       parent: [Circular],
       filename: '/path/to/node_modules/jquery/dist/jquery.js',
       loaded: true,
       children: [],
       paths: [Object] } ],
  paths:
   [ '/home/user/deleted/node_modules',
     '/home/user/node_modules',
     '/home/node_modules',
     '/node_modules' ]
}

module.exports屬性

module.exports屬性表示當(dāng)前模塊對(duì)外輸出的接口，其他文件加載該模塊，實(shí)際上就是讀取module.exports變量。

var EventEmitter = require('events').EventEmitter;
module.exports = new EventEmitter();

setTimeout(function() {
  module.exports.emit('ready');
}, 1000);

上面模塊會(huì)在加載后1秒后，發(fā)出ready事件。其他文件監(jiān)聽(tīng)該事件，可以寫成下面這樣。

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

exports變量

為了方便，Node為每個(gè)模塊提供一個(gè)exports變量，指向module.exports。這等同在每個(gè)模塊頭部，有一行這樣的命令。

var exports = module.exports;

造成的結(jié)果是，在對(duì)外輸出模塊接口時(shí)，可以向exports對(duì)象添加方法。

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

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

注意，不能直接將exports變量指向一個(gè)函數(shù)。因?yàn)檫@樣等于切斷了exports與module.exports的聯(lián)系。

exports = function (x){ console.log(x);};

上面這樣的寫法是無(wú)效的，因?yàn)樗袛嗔薳xports與module.exports之間的鏈接。

下面的寫法也是無(wú)效的。

exports.hello = function() {
  return 'hello';
};

module.exports = 'Hello world';

上面代碼中，hello函數(shù)是無(wú)法對(duì)外輸出的，因?yàn)?code>module.exports被重新賦值了。

如果一個(gè)模塊的對(duì)外接口，就是一個(gè)函數(shù)或?qū)ο髸r(shí)，不能使用exports輸出，只能使用module.exports輸出。

module.exports = function (x){ console.log(x);};

如果你覺(jué)得，exports與module.exports之間的區(qū)別很難分清，一個(gè)簡(jiǎn)單的處理方法，就是放棄使用exports，只使用module.exports。

AMD規(guī)范與CommonJS規(guī)范的兼容性

CommonJS規(guī)范加載模塊是同步的，也就是說(shuō)，只有加載完成，才能執(zhí)行后面的操作。AMD規(guī)范則是非同步加載模塊，允許指定回調(diào)函數(shù)。由于Node.js主要用于服務(wù)器編程，模塊文件一般都已經(jīng)存在于本地硬盤，所以加載起來(lái)比較快，不用考慮非同步加載的方式，所以CommonJS規(guī)范比較適用。但是，如果是瀏覽器環(huán)境，要從服務(wù)器端加載模塊，這時(shí)就必須采用非同步模式，因此瀏覽器端一般采用AMD規(guī)范。

AMD規(guī)范使用define方法定義模塊，下面就是一個(gè)例子：

define(['package/lib'], function(lib){
  function foo(){
    lib.log('hello world!');
  }

  return {
    foo: foo
  };
});

AMD規(guī)范允許輸出的模塊兼容CommonJS規(guī)范，這時(shí)define方法需要寫成下面這樣：

define(function (require, exports, module){
  var someModule = require("someModule");
  var anotherModule = require("anotherModule");

  someModule.doTehAwesome();
  anotherModule.doMoarAwesome();

  exports.asplode = function (){
    someModule.doTehAwesome();
    anotherModule.doMoarAwesome();
  };
});

require命令

基本用法

Node.js使用CommonJS模塊規(guī)范，內(nèi)置的require命令用于加載模塊文件。

require命令的基本功能是，讀入并執(zhí)行一個(gè)JavaScript文件，然后返回該模塊的exports對(duì)象。如果沒(méi)有發(fā)現(xiàn)指定模塊，會(huì)報(bào)錯(cuò)。

// example.js
var invisible = function () {
  console.log("invisible");
}

exports.message = "hi";

exports.say = function () {
  console.log(message);
}

運(yùn)行下面的命令，可以輸出exports對(duì)象。

var example = require('./example.js');
example
// {
//   message: "hi",
//   say: [Function]
// }

如果模塊輸出的是一個(gè)函數(shù)，那就不能定義在exports對(duì)象上面，而要定義在module.exports變量上面。

module.exports = function () {
  console.log("hello world")
}

require('./example2.js')()

上面代碼中，require命令調(diào)用自身，等于是執(zhí)行module.exports，因此會(huì)輸出 hello world。

加載規(guī)則

require命令接受模塊名作為參數(shù)。

（1）如果參數(shù)字符串以“/”開(kāi)頭，則表示加載的是一個(gè)位于絕對(duì)路徑的模塊文件。比如，require('/home/marco/foo.js')將加載/home/marco/foo.js。

（2）如果參數(shù)字符串以“./”開(kāi)頭，則表示加載的是一個(gè)位于相對(duì)路徑（跟當(dāng)前執(zhí)行腳本的位置相比）的模塊文件。比如，require('./circle')將加載當(dāng)前腳本同一目錄的circle.js。

（3）如果參數(shù)字符串不以“./“或”/“開(kāi)頭，則表示加載的是一個(gè)默認(rèn)提供的核心模塊（位于Node的系統(tǒng)安裝目錄中），或者一個(gè)位于各級(jí)node_modules目錄的已安裝模塊（全局安裝或局部安裝）。

舉例來(lái)說(shuō)，腳本/home/user/projects/foo.js執(zhí)行了require('bar.js')命令，Node會(huì)依次搜索以下文件。

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

這樣設(shè)計(jì)的目的是，使得不同的模塊可以將所依賴的模塊本地化。

（4）如果傳入require方法的是一個(gè)目錄，那么require會(huì)先查看該目錄的package.json文件，然后加載main字段指定的腳本文件。否則取不到main字段，則會(huì)加載index.js文件或index.node文件。

舉例來(lái)說(shuō)，下面是一行普通的require命令語(yǔ)句。

var utils = require( "utils" );

Node尋找utils腳本的順序是，首先尋找核心模塊，然后是全局安裝模塊，接著是項(xiàng)目安裝的模塊。

[
  '/usr/local/lib/node',
  '~/.node_modules',
  './node_modules/utils.js',
  './node_modules/utils/package.json',
  './node_modules/utils/index.js'
]

（5）如果指定的模塊文件沒(méi)有發(fā)現(xiàn)，Node會(huì)嘗試為文件名添加.js、.json、.node后，再去搜索。.js文件會(huì)以文本格式的JavaScript腳本文件解析，.json文件會(huì)以JSON格式的文本文件解析，.node文件會(huì)議編譯后二進(jìn)制文件解析。

（6）如果想得到require命令加載的確切文件名，使用require.resolve()方法。

模塊的緩存

第一次加載某個(gè)模塊時(shí)，Node會(huì)緩存該模塊。以后再加載該模塊，就直接從緩存取出該模塊的exports屬性。

require('./example.js');
require('./example.js').message = "hello";
require('./example.js').message
// "hello"

上面代碼中，連續(xù)三次使用require命令，加載同一個(gè)模塊。第二次加載的時(shí)候，為輸出的對(duì)象添加了一個(gè)message屬性。但是第三次加載的時(shí)候，這個(gè)message屬性依然存在，這就證明require命令并沒(méi)有重新加載模塊文件，而是輸出了緩存。

如果想要多次執(zhí)行某個(gè)模塊，可以輸出一個(gè)函數(shù)，然后多次調(diào)用這個(gè)函數(shù)。

緩存是根據(jù)絕對(duì)路徑識(shí)別模塊的，如果同樣的模塊名，但是保存在不同的路徑，require命令還是會(huì)重新加載該模塊。

模塊的循環(huán)加載

如果發(fā)生模塊的循環(huán)加載，即A加載B，B又加載A，則B將加載A的不完整版本。

// a.js
exports.x = 'a1';
console.log('a.js ', require('./b.js').x);
exports.x = 'a2';

// b.js
exports.x = 'b1';
console.log('b.js ', require('./a.js').x);
exports.x = 'b2';

// main.js
console.log('main.js ', require('./a.js').x);
console.log('main.js ', require('./b.js').x);

上面代碼是三個(gè)JavaScript文件。其中，a.js加載了b.js，而b.js又加載a.js。這時(shí)，Node返回a.js的不完整版本，所以執(zhí)行結(jié)果如下。

$ node main.js
b.js  a1
a.js  b2
main.js  a2
main.js  b2

修改main.js，再次加載a.js和b.js。

// main.js
console.log('main.js ', require('./a.js').x);
console.log('main.js ', require('./b.js').x);
console.log('main.js ', require('./a.js').x);
console.log('main.js ', require('./b.js').x);

執(zhí)行上面代碼，結(jié)果如下。

$ node main.js
b.js  a1
a.js  b2
main.js  a2
main.js  b2
main.js  a2
main.js  b2

上面代碼中，第二次加載a.js和b.js時(shí)，會(huì)直接從緩存讀取exports屬性，所以a.js和b.js內(nèi)部的console.log語(yǔ)句都不會(huì)執(zhí)行了。

require.main

正常的腳本調(diào)用時(shí)，require.main屬性指向模塊本身。

require.main === module
// true

如果是在REPL環(huán)境使用require命令，則上面的表達(dá)式返回false。

通過(guò)require.main屬性，可以獲取模塊的信息。比如，module對(duì)象有一個(gè)filename屬性（正常情況下等于 __filename），可以通過(guò)require.main.filename屬性，得知當(dāng)前模塊的入口文件。

參考鏈接

以上內(nèi)容是否對(duì)您有幫助：
在線筆記
App下載
App下載

掃描二維碼

下載編程獅App

公眾號(hào)
微信公眾號(hào)

編程獅公眾號(hào)