Commonjs規範及Node模塊實現

前面的話

　　Node在實現中並不是徹底按照CommonJS規範實現，而是對模塊規範進行了必定的取捨，同時也增長了少量自身須要的特性。本文將詳細介紹NodeJS的模塊實現

 

引入

　　nodejs是區別於javascript的，在javascript中的頂層對象是window，而在node中的頂層對象是global

　　[注意]實際上，javascript也存在global對象，只是其並不對外訪問，而使用window對象指向global對象而已

　　在javascript中，經過var a = 100；是能夠經過window.a來獲得100的

　　但在nodejs中，是不能經過global.a來訪問，獲得的是undefined

　　這是由於var a = 100;這個語句中的變量a，只是模塊範圍內的變量a，而不是global對象下的a

　　在nodejs中，一個文件就是一個模塊，每一個模塊都有本身的做用域。使用var來聲明的一個變量，它並非全局的，而是屬於當前模塊下

　　若是要在全局做用域下聲明變量，則以下所示

 

概述

　　Node中模塊分爲兩類：一類是Node提供的模塊，稱爲核心模塊；另外一類是用戶編寫的模塊，稱爲文件模塊

　　核心模塊部分在Node源代碼的編譯過程當中，編譯進了二進制執行文件。在Node進程啓動時，部分核心模塊就被直接加載進內存中，因此這部分核心模塊引入時，文件定位和編譯執行這兩個步驟能夠省略掉，而且在路徑分析中優先判斷，因此它的加載速度是最快的

　　文件模塊則是在運行時動態加載，須要完整的路徑分析、文件定位、編譯執行過程，速度比核心模塊慢

　　接下來，咱們展開詳細的模塊加載過程

 

模塊加載

　　在javascript中，加載模塊使用script標籤便可，而在nodejs中，如何在一個模塊中，加載另外一個模塊呢？

　　使用require()方法來引入

【緩存加載】

　　再展開介紹require()方法的標識符分析以前，須要知道，與前端瀏覽器會緩存靜態腳本文件以提升性能同樣，Node對引入過的模塊都會進行緩存，以減小二次引入時的開銷。不一樣的地方在於，瀏覽器僅僅緩存文件，而Node緩存的是編譯和執行以後的對象

　　不管是核心模塊仍是文件模塊，require()方法對相同模塊的二次加載都一概採用緩存優先的方式，這是第一優先級的。不一樣之處在於核心模塊的緩存檢查先於文件模塊的緩存檢查

【標識符分析】

　　require()方法接受一個標識符做爲參數。在Node實現中，正是基於這樣一個標識符進行模塊查找的。模塊標識符在Node中主要分爲如下幾類：[1]核心模塊，如http、fs、path等；[2].或..開始的相對路徑文件模塊；[3]以/開始的絕對路徑文件模塊；[4]非路徑形式的文件模塊，如自定義的connect模塊

　　根據參數的不一樣格式，require命令去不一樣路徑尋找模塊文件

　　一、若是參數字符串以「/」開頭，則表示加載的是一個位於絕對路徑的模塊文件。好比，require('/home/marco/foo.js')將加載/home/marco/foo.js

　　二、若是參數字符串以「./」開頭，則表示加載的是一個位於相對路徑（跟當前執行腳本的位置相比）的模塊文件。好比，require('./circle')將加載當前腳本同一目錄的circle.js

　　三、若是參數字符串不以「./「或」/「開頭，則表示加載的是一個默認提供的核心模塊（位於Node的系統安裝目錄中），或者一個位於各級node_modules目錄的已安裝模塊（全局安裝或局部安裝）

　　[注意]若是是當前路徑下的文件模塊，必定要以./開頭，不然nodejs會試圖去加載核心模塊，或node_modules內的模塊 

//a.js
console.log('aaa');

//b.js
require('./a');//'aaa'
require('a');//報錯

【文件擴展名分析】

　　require()在分析標識符的過程當中，會出現標識符中不包含文件擴展名的狀況。CommonJS模塊規範也容許在標識符中不包含文件擴展名，這種狀況下，Node會先查找是否存在沒有後綴的該文件，若是沒有，再按.js、.json、.node的次序補足擴展名，依次嘗試

　　在嘗試的過程當中，須要調用fs模塊同步阻塞式地判斷文件是否存在。由於Node是單線程的，因此這裏是一個會引發性能問題的地方。小訣竅是：若是是.node和.json文件，在傳遞給require()的標識符中帶上擴展名，會加快一點速度。另外一個訣竅是：同步配合緩存，能夠大幅度緩解Node單線程中阻塞式調用的缺陷

【目錄分析和包】

　　在分析標識符的過程當中，require()經過分析文件擴展名以後，可能沒有查找到對應文件，但卻獲得一個目錄，這在引入自定義模塊和逐個模塊路徑進行查找時常常會出現，此時Node會將目錄當作一個包來處理

　　在這個過程當中，Node對CommonJS包規範進行了必定程度的支持。首先，Node在當前目錄下查找package.json(CommonJS包規範定義的包描述文件)，經過JSON.parse()解析出包描述對象，從中取出main屬性指定的文件名進行定位。若是文件名缺乏擴展名，將會進入擴展名分析的步驟

　　而若是main屬性指定的文件名錯誤，或者壓根沒有package.json文件，Node會將index當作默認文件名，而後依次查找index.js、index.json、index.node

　　若是在目錄分析的過程當中沒有定位成功任何文件，則自定義模塊進入下一個模塊路徑進行查找。若是模塊路徑數組都被遍歷完畢，依然沒有查找到目標文件，則會拋出查找失敗的異常

 

訪問變量

　　如何在一個模塊中訪問另一個模塊中定義的變量呢？ 

【global】

　　最容易想到的方法，把一個模塊定義的變量複製到全局環境global中，而後另外一個模塊訪問全局環境便可

//a.js
var a = 100;
global.a = a;

//b.js
require('./a');
console.log(global.a);//100

　　這種方法雖然簡單，但因爲會污染全局環境，不推薦使用

【module】

　　而經常使用的方法是使用nodejs提供的模塊對象Module，該對象保存了當前模塊相關的一些信息

function Module(id, parent) {
    this.id = id;
    this.exports = {};
    this.parent = parent;
    if (parent && parent.children) {
        parent.children.push(this);
    }
    this.filename = null;
    this.loaded = false;
    this.children = [];
}

module.id 模塊的識別符，一般是帶有絕對路徑的模塊文件名。
module.filename 模塊的文件名，帶有絕對路徑。
module.loaded 返回一個布爾值，表示模塊是否已經完成加載。
module.parent 返回一個對象，表示調用該模塊的模塊。
module.children 返回一個數組，表示該模塊要用到的其餘模塊。
module.exports 表示模塊對外輸出的值。

【exports】

　　module.exports屬性表示當前模塊對外輸出的接口，其餘文件加載該模塊，實際上就是讀取module.exports變量

//a.js
var a = 100;
module.exports.a = a;

//b.js
var result = require('./a');
console.log(result);//'{ a: 100 }'

　　爲了方便，Node爲每一個模塊提供一個exports變量，指向module.exports。形成的結果是，在對外輸出模塊接口時，能夠向exports對象添加方法

console.log(module.exports === exports);//true

　　[注意]不能直接將exports變量指向一個值，由於這樣等於切斷了exports與module.exports的聯繫

 

模塊編譯

　　編譯和執行是模塊實現的最後一個階段。定位到具體的文件後，Node會新建一個模塊對象，而後根據路徑載入並編譯。對於不一樣的文件擴展名，其載入方法也有所不一樣，具體以下所示

　　js文件——經過fs模塊同步讀取文件後編譯執行

　　node文件——這是用C/C++編寫的擴展文件，經過dlopen()方法加載最後編譯生成的文件

　　json文件——經過fs模塊同步讀取文件後，用JSON.parse()解析返回結果

　　其他擴展名文件——它們都被當作.js文件載入

　　每個編譯成功的模塊都會將其文件路徑做爲索引緩存在Module._cache對象上，以提升二次引入的性能

　　根據不一樣的文件擴展名，Node會調用不一樣的讀取方式，如.json文件的調用以下：

// Native extension for .json
Module._extensions['.json'] = function(module, filename) {
    var content = NativeModule.require('fs').readFileSync(filename, 'utf8'); 
    try {
        module.exports = JSON.parse(stripBOM(content));
    } catch (err) {
        err.message = filename + ': ' + err.message;
        throw err;
    }
};

　　其中，Module._extensions會被賦值給require()的extensions屬性，因此經過在代碼中訪問require.extensions能夠知道系統中已有的擴展加載方式。編寫以下代碼測試一下：

console.log(require.extensions);

　　獲得的執行結果以下：

{ '.js': [Function], '.json': [Function], '.node': [Function] }

　　在肯定文件的擴展名以後，Node將調用具體的編譯方式來將文件執行後返回給調用者

【JavaScript模塊的編譯】

　　回到CommonJS模塊規範，咱們知道每一個模塊文件中存在着require、exports、module這3個變量，可是它們在模塊文件中並無定義，那麼從何而來呢？甚至在Node的API文檔中，咱們知道每一個模塊中還有filename、dirname這兩個變量的存在，它們又是從何而來的呢？若是咱們把直接定義模塊的過程放諸在瀏覽器端，會存在污染全局變量的狀況

　　事實上，在編譯的過程當中，Node對獲取的JavaScript文件內容進行了頭尾包裝。在頭部添加了(function(exports, require, module, filename, dirname) {\n，在尾部添加了\n});

　　一個正常的JavaScript文件會被包裝成以下的樣子

(function (exports, require, module,  filename,  dirname) {
    var math = require('math');
    exports.area = function (radius) {
        return Math.PI * radius * radius;
    };
});

　　這樣每一個模塊文件之間都進行了做用域隔離。包裝以後的代碼會經過vm原生模塊的runInThisContext()方法執行(相似eval，只是具備明確上下文，不污染全局)，返回一個具體的function對象。最後，將當前模塊對象的exports屬性、require()方法、module(模塊對象自身)，以及在文件定位中獲得的完整文件路徑和文件目錄做爲參數傳遞給這個function()執行

　　這就是這些變量並無定義在每一個模塊文件中卻存在的緣由。在執行以後，模塊的exports屬性被返回給了調用方。exports屬性上的任何方法和屬性均可以被外部調用到，可是模塊中的其他變量或屬性則不可直接被調用

　　至此，require、exports、module的流程已經完整，這就是Node對CommonJS模塊規範的實現

【C/C++模塊的編譯】

　　Node調用process.dlopen()方法進行加載和執行。在Node的架構下，dlopen()方法在Windows和*nix平臺下分別有不一樣的實現，經過libuv兼容層進行了封裝

　　實際上，.node的模塊文件並不須要編譯，由於它是編寫C/C++模塊以後編譯生成的，因此這裏只有加載和執行的過程。在執行的過程當中，模塊的exports對象與.node模塊產生聯繫，而後返回給調用者

　　C/C++模塊給Node使用者帶來的優點主要是執行效率方面的，劣勢則是C/C++模塊的編寫門檻比JavaScript高

【JSON文件的編譯】

　　.json文件的編譯是3種編譯方式中最簡單的。Node利用fs模塊同步讀取JSON文件的內容以後，調用JSON.parse()方法獲得對象，而後將它賦給模塊對象的exports，以供外部調用

　　JSON文件在用做項目的配置文件時比較有用。若是你定義了一個JSON文件做爲配置，那就沒必要調用fs模塊去異步讀取和解析，直接調用require()引入便可。此外，你還能夠享受到模塊緩存的便利，而且二次引入時也沒有性能影響

 

CommonJS

　　在介紹完Node的模塊實現以後，回過頭來再學習下CommonJS規範，相對容易理解

　　CommonJS規範的提出，主要是爲了彌補當前javascript沒有標準的缺陷，使其具有開發大型應用的基礎能力，而不是停留在小腳本程序的階段

　　CommonJS對模塊的定義十分簡單，主要分爲模塊引用、模塊定義和模塊標識3個部分

【模塊引用】

var math = require('math');

　　在CommonJS規範中，存在require()方法，這個方法接受模塊標識，以此引入一個模塊的API到當前上下文中

【模塊定義】

　　在模塊中，上下文提供require()方法來引入外部模塊。對應引入的功能，上下文提供了exports對象用於導出當前模塊的方法或者變量，而且它是惟一導出的出口。在模塊中，還存在一個module對象，它表明模塊自身，而exports是module的屬性。在Node中，一個文件就是一個模塊，將方法掛載在exports對象上做爲屬性便可定義導出的方式：

// math.js
exports.add = function () {
    var sum = 0, i = 0,args = arguments, l = args.length;
    while (i < l) {
        sum += args[i++];
    }
    return sum;
};

　　在另外一個文件中，咱們經過require()方法引入模塊後，就能調用定義的屬性或方法了

// program.js
var math = require('math');
exports.increment = function (val) {
    return math.add(val, 1);
};

【模塊標識】

　　模塊標識其實就是傳遞給require()方法的參數，它必須是符合小駝峯命名的字符串，或者以.、..開頭的相對路徑，或者絕對路徑。它能夠沒有文件名後綴.js

　　模塊的定義十分簡單，接口也十分簡潔。它的意義在於將類聚的方法和變量等限定在私有的做用域中，同時支持引入和導出功能以順暢地鏈接上下游依賴。每一個模塊具備獨立的空間，它們互不干擾，在引用時也顯得乾淨利落