前言

js是從網(wǎng)頁小腳本演變過來的，至今，前端的js庫，也不像一個(gè)真正的模塊。前端js經(jīng)歷了工具類庫、組件庫、前端框架和前端應(yīng)用的變遷。但是，依然沒有完成真正的模塊化轉(zhuǎn)變（也就是不斷的聚類和抽象）。因?yàn)?，js沒有模塊，因此，也就沒辦法完成真正的封裝等工作，只能通過人為的命名空間來約束代碼。

前端js的發(fā)展之路

這個(gè)第二章就是講nodejs模塊機(jī)制的。另外，由于原書的第二章編排的比較混亂，因此，我的筆記也做了結(jié)構(gòu)上的調(diào)整。

CommonJS規(guī)范

CommonJS出現(xiàn)之前，js存在很多問題，沒有模塊系統(tǒng)、標(biāo)準(zhǔn)庫較少、沒有標(biāo)準(zhǔn)接口（例如數(shù)據(jù)庫連接接口等）、缺乏包管理系統(tǒng)。

CommonJS的美好愿景是希望js在任何地方都可以運(yùn)行。也就是說，js不僅僅可以開發(fā)網(wǎng)頁程序，還可以開發(fā)服務(wù)器端程序、命令行工具、桌面應(yīng)用以及混合應(yīng)用。CommonJS規(guī)范涵蓋了模塊、二進(jìn)制、Buffer、字符集編碼、IO流、進(jìn)程環(huán)境、文件系統(tǒng)、套接字、單元測試、Web服務(wù)網(wǎng)關(guān)接口、包管理等。這種關(guān)系可以用下邊的圖來表示：

w3c、CommonJS以及Node之間的關(guān)系

node借助CommonJS的Modules規(guī)范，實(shí)現(xiàn)了一套非常易用的模塊系統(tǒng)，接下來，我們就講講這個(gè)由npm管理的模塊系統(tǒng)。

CommonJS的模塊規(guī)范

CommonJS的模塊規(guī)范包含三個(gè)部分：模塊引用、模塊定義和模塊標(biāo)識。

模塊引用

const math = require('math');

上邊的代碼展示了模塊引用的方法，使用的是CommonJS規(guī)范中定義的require()方法。通過require引入一個(gè)模塊API到當(dāng)前的上下文中。

模塊定義

對于引入的模塊，CommonJS在上下文中提供了exports對象用于導(dǎo)出當(dāng)前模塊的方法或者變量，同時(shí)exports也是模塊的唯一出入口，這個(gè)就類似于面向?qū)ο蟮姆庋b特性了。在模塊中，還存在一個(gè)module對象，它代表模塊自身，也就是說，在node中，一個(gè)文件就是一個(gè)模塊，這個(gè)module就代表了這個(gè)文件，而這個(gè)exports只是module的一個(gè)屬性。

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

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

模塊定義

模塊標(biāo)識

模塊標(biāo)識其實(shí)就是傳遞給require()方法的參數(shù)，這個(gè)參數(shù)需要符合如下特點(diǎn)：

1.建議使用小駝峰命名字符串
2.以.或..的相對路徑開頭，或者直接使用絕對路徑。當(dāng)然，如果在同一個(gè)目錄下，也可以直接引入。
3.文件名不需要文件名后綴.js

小結(jié)

CommonJS構(gòu)建的這套模塊導(dǎo)出和引入機(jī)制使得用戶完全不必考慮變量污染，命名空間等方案與之相比相形見絀。

Node的模塊實(shí)現(xiàn)

node模塊分類

node模塊引入的步驟

路徑分析、文件定位和編譯執(zhí)行。

模塊加載

node模塊會優(yōu)先從緩存加載，前端瀏覽器會緩存靜態(tài)腳本文件以提高前端的訪問速度，因此，node對引入過的模塊都會進(jìn)行緩存，以減少二次引入時(shí)的開銷。不同之處在于，瀏覽器緩存文件，node緩存的是編譯和執(zhí)行后的對象。不論是核心模塊還是文件模塊，require()方法對相同模塊的二次加載都一律采用緩存優(yōu)先的方式，這被稱為第一優(yōu)先級。當(dāng)然，核心模塊的緩存檢查先于文件模塊的緩存檢查。

優(yōu)先從緩存加載，例如幾個(gè)文件都用了const router = require('koa-router')();路由這個(gè)模塊，那么可以在初始化node的時(shí)候就將這個(gè)模塊加載到緩存中，這樣，可以提高后續(xù)應(yīng)用中模塊的訪問速度。

路徑分析和文件定位

因?yàn)?，?biāo)識符有幾種形式:

1.核心模塊：如http、fs、path等。
2..或者..開始的相對路徑文件模塊。
3.以/開始的絕對路徑文件模塊。
4.非路徑形式的文件模塊，例如自定義的connect模塊。

核心模塊

核心模塊的優(yōu)先級，僅次于緩存加載，它在node的源代碼編輯過程中已經(jīng)編譯為二進(jìn)制代碼，加載速度最快。（注意：在自定義的標(biāo)識符命名上，請不要和核心模塊產(chǎn)生沖突）

核心模塊加載時(shí)第二快的。

路徑形式的文件模塊

以.、..和/開始的標(biāo)識符，這里都被當(dāng)做文件模塊來處理，require會將這些路徑轉(zhuǎn)化成真實(shí)路徑，并以真實(shí)路徑作為索引，然后，將編譯結(jié)果放入緩存，以加快二次加載。

路徑形式的文件模塊加載時(shí)第三快的。

自定義模塊

自定義模塊可能是一個(gè)文件或者是一個(gè)包，因?yàn)榧炔皇呛诵哪K，又沒有路徑，因此加載速度是最慢的。為了更好的理解自定義模塊，我們先來了解一下模塊路徑這個(gè)概念。

模塊路徑

console.log(module.paths);

通過這個(gè)語句可以查看模塊路徑，得到的模塊路徑是一個(gè)路徑數(shù)組。

//linux
[ '/home/jackson/research/node_modules',
'/home/jackson/node_modules',
'/home/node_modules',
'/node_modules' ]

//win
[ 'c:\\nodejs\\node_modules', 'c:\\node_modules' ]

我們可以看出，這個(gè)模塊路徑的生成規(guī)則是：
1.當(dāng)前文件目錄下的node_modules目錄
2.父目錄下的的node_modules目錄
3.爺爺目錄下的node_modules目錄
4.祖宗目錄下的的node_modules目錄，也就是向上一直找，直到根目錄下的node_modules目錄

這個(gè)查找方式很像原型鏈或者作用域鏈。在加載過程中，node會逐步嘗試模塊路徑中的路徑，直到找到文件為止，那么如果路徑越深，模塊查找耗時(shí)就會越多，加載時(shí)間也就會越慢。

文件定位

文件擴(kuò)展名分析、目錄和包的處理。

文件擴(kuò)展名分析

1.require中不需要包含擴(kuò)展名，node會按照.js、.json、.node的次序補(bǔ)足擴(kuò)展名。由于，在這個(gè)過程中，node會調(diào)用fs進(jìn)行單線程阻塞，因此，可以為json和.node的文件加上擴(kuò)展名，以此提高效率。

另外，書中說的一句話：同步配合緩存，可以大幅度緩解node單線程中阻塞式調(diào)用的缺陷，我沒有明白，準(zhǔn)備問問作者去，或者以后慢慢體會。

目錄分析和包

如果文件沒有找到，但是查到了一個(gè)目錄的話，此時(shí)會將目錄當(dāng)做包來處理。首先，會在這個(gè)目錄下尋找package.json，通過JSON.parse()解析出包的描述對象，從中取出main屬性制定的文件名進(jìn)行定位。如果這些都沒有，則會默認(rèn)把index.js或者index.json或者index.node作為制定的加載文件。如果都沒有，就會報(bào)錯了。

模塊編譯

node中每個(gè)文件就是一個(gè)模塊，他的定義如下：

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 = [];
}

編譯過程會對不同的文件類型進(jìn)行區(qū)分：
1.js文件，通過fs模塊同步讀取后，并編譯。
2.node文件，這是用c/c++編寫的擴(kuò)展文件，通過dlopen()方法加載并編譯。
3.json文件，通過fs模塊同步讀取后，用JSON.parse()解析并返回結(jié)果。代碼如下：

// 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;
    }
};

console.log(require.extensions);

//{ '.js': [Function], '.json': [Function], '.node': [Function] }
//通過require.extensions可以查看到已有的擴(kuò)展加載方式

4.其他文件，當(dāng)做js文件處理。

每一個(gè)編譯成功的模塊都會將文件路徑作為索引緩存到Module._cache對象中，提高了二次引入的性能。

js模塊編譯

基于CommonJS模塊規(guī)范，每一個(gè)模塊文件都包含require、exports、module三個(gè)變量，同時(shí)，node API中還提供了__filename、__dirname這兩個(gè)變量。這些，都是在編譯過程中，由node進(jìn)行的包裝，并自動添加的，我們看一下編譯后的樣子：

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

這樣，每個(gè)文件模塊之間都有了作用域隔離，包裝后，代碼會通過vm原生模塊（這里就是V8的原生模塊）調(diào)用runInThisContext()方法執(zhí)行（類似于eval），返回一個(gè)具體的function對象。這個(gè)對象，就可以被其他文件（也是模塊）調(diào)用了，只不過調(diào)用只限于使用exports上的屬性和方法。

另外，由于exports對象是通過形式參數(shù)傳遞的，因此，直接改變賦值只會改變該形參，但不能改變作用域外的值，例如:

var change = function (a) {
a = 100;
console.log(a); // => 100
};
var a = 10;
change(a);
console.log(a); // => 10

在這種情況下，使用module.exports就可以了。

私有方法的測試

此處還需要了解另外一種引入，rewire，他會在編譯代碼的時(shí)候，為代碼增加set和get方法，通過閉包將私有方法對外暴露。

在模塊中的沒有用exports引用的都是私有方法，這部分的測試也很重要。我們可以使用rewire來進(jìn)行私有模塊的測試，也就是使用rewire引用模塊

//
var limit = function (num) {
    return num < 0 ? 0 : num;
};

//測試用例
it('limit should return success', function () {
    var lib = rewire('../lib/index.js');
    var litmit = lib.__get__('limit');
    litmit(10).should.be.equal(10);
});

rewire的模塊引入和require一樣，都會為原始文件增加參數(shù)：

(function(exports, require, module, __filename, __dirname) {? })

此外，他還會注入其他的代碼：

(function (exports, require, module, __filename, __dirname) {
    var method = function () { };
    exports.__set__ = function (name, value) {
        eval(name " = " value.toString());
    };
    exports.__get__ = function (name) {
        return eval(name);
    };
});

每一個(gè)被rewire引入的模塊，都會有set()和get()方法，這個(gè)就是巧妙的利用了閉包的原理，在eval()執(zhí)行時(shí)，實(shí)現(xiàn)了對模塊內(nèi)部局部變量的訪問，從而可以將局部變量導(dǎo)出給測試用例進(jìn)行調(diào)用執(zhí)行。

node模塊編譯（c/c++模塊）

通過process.dlopen()進(jìn)行編譯，但是，實(shí)際上.node是已經(jīng)通過c/c++編譯完成的文件，因此，這個(gè)編譯過程只是將.node文件進(jìn)行關(guān)聯(lián)和加入緩存。后邊，我們將會講解如何自己編譯c/c++文件，并得到.node文件。

json模塊編譯

這個(gè)是最直接，也是最簡單的，node會直接將json在require的作用下解析為可以使用的字符串并關(guān)聯(lián)到exports上，都做完后，還會進(jìn)行緩存，提高再次調(diào)用的效率。因此，不必自己再次調(diào)用JSON.parse()方法了，去解析json了。

核心模塊

node的核心模塊是c/c++和js寫的，其中c/c++文件源碼保存在node項(xiàng)目的src下，js文件源碼保存在node的lib下。

js核心模塊編譯

1.首先會將js模塊文件編譯為c/c++代碼，然后才會編譯c/c++文件。
2.轉(zhuǎn)存這些由js編譯為的c/c++代碼，這里node采用了v8附帶的js2c.py工具，將內(nèi)置的js代碼（src/node.js和lib/*.js）轉(zhuǎn)換為c++里的數(shù)組，生成node_natives.h頭文件。我們看看代碼:

namespace node {
    const char node_native[] = { 47, 47, ..};
    const char dgram_native[] = { 47, 47, ..};
    const char console_native[] = { 47, 47, ..};
    const char buffer_native[] = { 47, 47, ..};
    const char querystring_native[] = { 47, 47, ..};
    const char punycode_native[] = { 47, 42, ..};
    ...
    struct _native {
        const char* name;
        const char* source;
        size_t source_len;
    };
    static const struct _native natives[] = {
    { "node", node_native, sizeof(node_native) - 1 },
    { "dgram", dgram_native, sizeof(dgram_native) - 1 },
    ...
};
    }

這個(gè)過程中，js代碼以字符串的形式存儲在node命名空間中，是不可以被直接執(zhí)行的。在啟動node進(jìn)程時(shí)，js代碼直接加載進(jìn)內(nèi)存，在加載的過程中，js核心模塊經(jīng)歷標(biāo)識符分析后直接定位到內(nèi)存中，比普通的文件模塊從磁盤中一處一處查找要快的多。

編譯過程

與普通js模塊一樣，核心模塊也會經(jīng)歷包裝的過程，將require、exports、module、__filename、__dirname等參數(shù)增加上，并完成作用域分離。但是，這些js代碼是從內(nèi)存加載而來的，也就是在process.binding('natives')取出，編譯后會緩存在NativeModule._cache對象上。此處代碼如下：

function NativeModule(id) {
this.filename = id + '.js';
this.id = id;
this.exports = {};
this.loaded = false;
}
NativeModule._source = process.binding('natives');
NativeModule._cache = {};

c/c++核心模塊編譯過程

在核心模塊中，有些模塊全部由c/c++編寫，有些模塊則由c/c++完成核心部分，其他部分則由js實(shí)現(xiàn)包裝或向外導(dǎo)出，以滿足性能需求，這也是node能夠提高性能的一種常見方式。

這些全部由c/c++編寫的模塊被稱為內(nèi)建模塊，例如:buffer、crypto、evals、fs、os等

內(nèi)建模塊的組織形式

內(nèi)建模塊的結(jié)構(gòu)定義如下：

struct node_module_struct {
int version;
void *dso_handle;
const char *filename;
void (*register_func) (v8::Handle<v8::Object> target);
const char *modname;
};

每一個(gè)內(nèi)建模塊在定義后，都通過NODE_MODULE宏將模塊定義到node命名空間中，模塊的具體初始化方法掛載為結(jié)構(gòu)的register_func成員:

#define NODE_MODULE(modname, regfunc) \
extern "C" { \
NODE_MODULE_EXPORT node::node_module_struct modname ## _module = \
{ \
NODE_STANDARD_MODULE_STUFF, \
regfunc, \
NODE_STRINGIFY(modname) \
}; \
}

node_extensions.h文件將這些散列的內(nèi)建模塊統(tǒng)一放入一個(gè)叫node_module_list的數(shù)組中，這些模塊有：

node_buffer
node_crypto
node_evals
node_fs
node_http_parser
node_os
node_zlib
node_timer_wrap
node_tcp_wrap
node_udp_wrap
node_pipe_wrap
node_cares_wrap
node_tty_wrap
node_process_wrap
node_fs_event_wrap
node_signal_watcher

這些內(nèi)建模塊的取出也十分簡單，node提供了get_builtin_module()方法，從node_module_list數(shù)組中取出這些模塊。

內(nèi)建模塊的優(yōu)勢在于，c/c++的效率高于js，編譯后直接變?yōu)槎M(jìn)制文件，進(jìn)入緩存，直接調(diào)用。

內(nèi)建模塊的導(dǎo)出

文件模塊依賴核心模塊，核心模塊依賴內(nèi)建模塊。我們看個(gè)圖：

依賴關(guān)系

因此，文件模塊不推薦調(diào)用內(nèi)建模塊，但是可以通過process.Binding()來加載內(nèi)建模塊（Binding()的實(shí)現(xiàn)正在src/node.cc中，當(dāng)然，如果不是十分了解內(nèi)建模塊，請慎重使用process.binding()來之間調(diào)用內(nèi)建模塊）

static Handle < Value > Binding(const Arguments& args) {
    HandleScope scope;
Local < String > module = args[0] -> ToString();
String:: Utf8Value module_v(module);
node_module_struct * modp;
if (binding_cache.IsEmpty()) {
    binding_cache = Persistent<Object>:: New(Object:: New());
}
Local < Object > exports;
if (binding_cache -> Has(module)) {
    exports = binding_cache -> Get(module) -> ToObject();
    return scope.Close(exports);
}
// Append a string to process.moduleLoadList
char buf[1024];
snprintf(buf, 1024, "Binding s", * module_v); %
    uint32_t l = module_load_list -> Length();
module_load_list -> Set(l, String:: New(buf));
if ((modp = get_builtin_module(* module_v)) != NULL) {
    exports = Object:: New();
    modp -> register_func(exports);
    binding_cache -> Set(module, exports);
} else if (!strcmp(* module_v, "constants")) {
    exports = Object:: New();
    DefineConstants(exports);
    binding_cache -> Set(module, exports);
    #ifdef __POSIX__
} else if (!strcmp(* module_v, "io_watcher")) {
    exports = Object:: New();
    IOWatcher:: Initialize(exports);
    binding_cache -> Set(module, exports);
    #endif
} else if (!strcmp(* module_v, "natives")) {
    exports = Object:: New();
    DefineJavaScript(exports);
    binding_cache -> Set(module, exports);
} else {
    return ThrowException(Exception:: Error(String:: New("No such module")));
}
return scope.Close(exports);
    }

在加載內(nèi)建模塊時(shí)，先創(chuàng)建一個(gè)exports空對象，然后調(diào)用get_builtin_module()方法取出內(nèi)建模塊對象，接著執(zhí)行register_func()填充到exports空對象上，最后，將exports對象按照模塊名緩存，并返回給調(diào)用方。

這個(gè)方法還可以導(dǎo)出其他內(nèi)容，例如js核心文件被c/c++數(shù)組存儲后，可以通過process.binding('natives')取出NativeModule._source

NativeModule._source = process.binding('natives');

該方法將通過js2c.py工具轉(zhuǎn)換出的字符串?dāng)?shù)組取出，然后重新轉(zhuǎn)換為普通字符串，已對js核心模塊進(jìn)行編譯和執(zhí)行。

核心模塊的引入流程

看圖就明白了

核心模塊的引入流程

核心模塊的編寫

前邊說了這么多，其實(shí)就是為編寫核心模塊做準(zhǔn)備的。當(dāng)然，盡管我們沒有參與核心模塊編寫的機(jī)會，但是，了解其原理，總是好的。

我們給出一個(gè)簡單的js版本模型，也就是hello world來看一下如何編寫c/c++核心模塊。

exports.sayHello = function () {
return 'Hello world!';
};

第一步：編寫頭文件和編寫c/c++
寫一個(gè)node_hello.h并保存到node的src下

#ifndef NODE_HELLO_H_
#define NODE_HELLO_H_
#include <v8.h>
namespace node {
// 預(yù)定義方法
v8::Handle<v8::Value> SayHello(const v8::Arguments& args);
}
#endif

第二步編寫node_hello.cc并保存到node的src下

#include < node.h >
#include < node_hello.h >
#include < v8.h >
    namespace node {
    using namespace v8;
    // 實(shí)現(xiàn)預(yù)定義的方法
    Handle < Value > SayHello(const Arguments& args) {
HandleScope scope;
    return scope.Close(String:: New("Hello world!"));
}
// 給傳入的目標(biāo)對象添加sayHello方法
void Init_Hello(Handle < Object > target) {
    target -> Set(String:: NewSymbol("sayHello"), FunctionTemplate:: New(SayHello) -> GetFunction());
}
}
// 調(diào)用NODE_MODULE()將注冊方法定義到內(nèi)存中
NODE_MODULE(node_hello, node:: Init_Hello)

第三步：

修改src/node_extensions.h，在NODE_EXT_LIST_END前，添加NODE_EXT_LIST_ITEM(node_hello)，以此，將node_hello加入到node_module_list數(shù)組中。

第四步：

編譯兩份代碼，變?yōu)榭蓤?zhí)行文件。

第五步：

修改node.gyp，并在target_name:node節(jié)點(diǎn)的sources中添加上新編寫的兩個(gè)文件。然后，從新編譯整個(gè)node項(xiàng)目。

編譯安裝后，就可以使用了。

$ node
> var hello = process.binding('hello');
> hello.sayHello();
'Hello world!'
>

c/c++擴(kuò)展模塊

js的位運(yùn)算是參考java實(shí)現(xiàn)的，但是，java的位運(yùn)算是基于int的，js中只有double，因此，需要先將double轉(zhuǎn)換為int，因此，效率不是很高。

在應(yīng)用中，會存在大量的位運(yùn)算需求，包括轉(zhuǎn)碼、編碼、解碼等，此時(shí)，可以使用c/c++擴(kuò)展模塊來節(jié)省cpu資源。

c/c++擴(kuò)展模塊屬于node文件模塊的一類，首先將c/c++編譯為.node文件，然后通過process.dlopen()方法加載執(zhí)行。（此處需要注意，不同平臺由于編譯器的差異，因此，編譯的結(jié)果其實(shí)也不一樣，inx下通過g++/gcc編譯為的是.so，win下編譯出的是.dll，node統(tǒng)一將其命名為*.node），我們來看下邊這個(gè)圖做的詳細(xì)介紹：

擴(kuò)展模塊不同平臺上的編譯和加載過程

前提條件

1.GYP項(xiàng)目生產(chǎn)工具，Generate Your Projects，哈哈哈，生成你的項(xiàng)目，may the force be with you....通過gyp工具，幫助生成各個(gè)平臺下的項(xiàng)目文件，例如win下的.sln，mac下的文件等，另外，node自身編碼其實(shí)就是通過gyp編譯的，我們還可以找一個(gè)擴(kuò)展工具node-gyp，安裝如下：

npm install -g node-gyp

2.V8引擎c++庫，v8是c++寫的，實(shí)現(xiàn)js和c++相互調(diào)用
3.libuv庫，通過libuv調(diào)用底層功能，例如事件循環(huán)的epoll，還有文件操作等等
4.node內(nèi)部庫，例如node::ObjectWrap類可以用于包裝你自己寫的自定義類，它可以幫助實(shí)現(xiàn)對象回收等工作。
5.其他庫，這些庫存在于deps下，例如zlib、openssl、http_parser

c/c++擴(kuò)展模塊的編寫

前邊鋪墊了這么多，終于要進(jìn)行編寫了，好激動哈哈哈哈。

c/c++擴(kuò)展模塊，可以先編譯，然后直接通過dlopen()動態(tài)加載，不需要跟隨node一起編譯。

我們來看一下同樣的hello world是如何加載的：

exports.sayHello = function () {
return 'Hello world!';
};

編寫hello.cc，并存儲到src下

#include <node.h>
#include <v8.h>
using namespace v8;
// 實(shí)現(xiàn)預(yù)定義的方法
Handle<Value> SayHello(const Arguments& args) {
HandleScope scope;
return scope.Close(String::New("Hello world!"));
}
// 給傳入的目標(biāo)對象添加sayHello()方法
void Init_Hello(Handle<Object> target) {
target->Set(String::NewSymbol("sayHello"), FunctionTemplate::New(SayHello)->GetFunction());
}
// 調(diào)用NODE_MODULE()方法將注?方法定義到內(nèi)存中
NODE_MODULE(hello, Init_Hello)

然后，將方法掛載到target對象上，然后通過NODE_MODULE聲明即可。

然后就可以通過dlopen()動態(tài)加載了。

c/c++擴(kuò)展模塊的編譯

在gyp的幫助下進(jìn)行編譯，先寫*.gyp文件，然后調(diào)用node-gyp進(jìn)行編譯，這個(gè)文件被約定外binding.gyp

{
    'targets': [
        {
            'target_name': 'hello',
            'sources': [
                'src/hello.cc'
            ],
            'conditions': [
                ['OS == "win"',
                    {
                        'libraries': ['-lnode.lib']
                    }
                ]
            ]
        }
    ]
}

然后執(zhí)行：

node-gyp configure

輸出結(jié)果：

gyp info it worked if it ends with ok
gyp info using node-gyp@0.8.3
gyp info using node@0.8.14 | darwin | x64
gyp info spawn python
gyp info spawn args [ '/usr/local/lib/node_modules/node-gyp/gyp/gyp',
gyp info spawn args 'binding.gyp',
gyp info spawn args '-f',
gyp info spawn args 'make',
gyp info spawn args '-I',
gyp info spawn args '/Users/jacksontian/git/diveintonode/examples/02/addon/build/config.gypi',
gyp info spawn args '-I',
gyp info spawn args '/usr/local/lib/node_modules/node-gyp/addon.gypi',
gyp info spawn args '-I',
gyp info spawn args '/Users/jacksontian/.node-gyp/0.8.14/common.gypi',
gyp info spawn args '-Dlibrary=shared_library',
gyp info spawn args '-Dvisibility=default',
gyp info spawn args '-Dnode_root_dir=/Users/jacksontian/.node-gyp/0.8.14',
gyp info spawn args '-Dmodule_root_dir=/Users/jacksontian/git/diveintonode/examples/02/addon',
gyp info spawn args '--depth=.',
gyp info spawn args '--generator-output',
gyp info spawn args 'build',
gyp info spawn args '-Goutput_dir=.' ]
gyp info ok

node-gyp configure會在當(dāng)前目錄創(chuàng)建build目錄，并生成相關(guān)的項(xiàng)目文件，*inx下build目錄會有Makefile等文件，win下，會生成vcxproj等文件

然后執(zhí)行構(gòu)建命令

$ node-gyp build

會輸出

gyp info it worked if it ends with ok
gyp info using node-gyp@0.8.3
gyp info using node@0.8.14 | darwin | x64
gyp info spawn make
gyp info spawn args [ 'BUILDTYPE=Release', '-C', 'build' ]
CXX(target) Release/obj.target/hello/hello.o
SOLINK_MODULE(target) Release/hello.node
SOLINK_MODULE(target) Release/hello.node: Finished
gyp info ok

最終獲得了build/Release/hello.node文件。

c/c++擴(kuò)展模塊的加載

直接使用require就可以了，這里node會調(diào)用process.dlopen()動態(tài)加載這個(gè)文件，然后使用即可。

var hello = require('./build/Release/hello.node');
//這里node會調(diào)用process.dlopen()動態(tài)加載這個(gè)文件：
//Native extension for .node
//Module._extensions['.node'] = process.dlopen;
console.log(hello.sayHello());

process.dlopen()的引入過程

1.通過libuv庫，調(diào)用uv_dlopen()打開動態(tài)鏈接庫。
2.通過libuv庫，調(diào)用uv_dlsym()找到動態(tài)鏈接庫中通過NODE_MODULE宏定義的方法地址。

注意:libuv是一層封裝，那么在*inx下調(diào)用的是dlfcn.h?頭文件定義的dlopen()和dlsym()，在win下則是LoadLibraryExW()和GetProcAddress()

process.dlopen()的引入過程

由于編寫模塊時(shí)，通過NODE_MODULE將模塊定義為node_module_struct結(jié)構(gòu)，所以在獲取函數(shù)地址之后，將它映射為node_module_struct幾乎是無縫對接的。接下來的過程就是講傳入的exports對象作為實(shí)參運(yùn)行，將c++中定義的方法掛載在exports對象上，這樣就可以實(shí)現(xiàn)跟js文件模塊一樣的調(diào)用效果了。另外，因?yàn)椋?.node是已經(jīng)編譯好的，因此，無需在加載后進(jìn)行編譯，這也提高了一些速度。

模塊調(diào)用棧

模塊調(diào)用棧，也就是各個(gè)模塊之間的調(diào)用關(guān)系。

模塊之間的調(diào)用關(guān)系

通過這個(gè)圖，我們還可以看出js模塊既可以是功能模塊，也可是作為c/c++模塊的包裝。

包與npm

首先，我們來看一下弱類型的js是如何基于CommonJS實(shí)現(xiàn)包組織模塊的：

包組織模塊示意圖

同時(shí)，CommonJS對于包的規(guī)范也很簡單，只有包結(jié)構(gòu)和包描述兩部分。

包結(jié)構(gòu)

符合commonjs規(guī)范的包是這樣?jì)鸬模?br> 1.package.json，包描述文件
2.bin，存放可執(zhí)行二進(jìn)制文件的目錄，有時(shí)，開發(fā)的程序可能是一個(gè)命令行工具，因此，通過全局安裝，那么就可以到bin下找到執(zhí)行命令的工具了。
3.lib，用于存放js代碼的目錄
4.doc，用于存放文檔的目錄
5.test，用于存放單元測試用例的代碼的目錄

包描述

包描述文件，就是一個(gè)package.json，它需要包含：
1.name，包名，包名必須是唯一的。
2.description，包簡介
3.version，版本號。通常為major.minor.revision的格式，版本號可以控制npm下載不同的版本，確認(rèn)是開發(fā)版本還是測試版本等。
4.keywords，幫助npm進(jìn)行搜索。
5.maintaners，維護(hù)者列表，格式是maintaners:[{name,email,web}]
6.contributors，貢獻(xiàn)者列表，格式是contributors:[{name,email,web}]
7.bugs，反饋bugs的網(wǎng)址
8.licenses，許可。
9.repositories，代碼托管地址
10.dependencies，包依賴，通過這個(gè)依賴可以確認(rèn)那些包需要被下載。
11.homepage，可選，當(dāng)前包的相關(guān)網(wǎng)頁
12.os，操作系統(tǒng)
13.cpu，cpu
14.engine，支持js的引擎，可以填寫ejs、 flusspferd、 gpsee、 jsc、spidermonkey、 narwhal、 node和v8。
15.builtin，標(biāo)志當(dāng)前包是否是內(nèi)建在底層系統(tǒng)的標(biāo)志組件
16.directories，包目錄說明
17.implements，實(shí)現(xiàn)規(guī)范，標(biāo)志當(dāng)前包實(shí)現(xiàn)了哪些commonjs規(guī)范。
18.scripts，腳本對象說明，說明安裝、編譯、測試、卸載

"scripts": { "install": "install.js",
"uninstall": "uninstall.js",
"build": "build.js",
"doc": "make-doc.js",
"test": "test.js" }

19.author，包作者
20.main，require()會尋找main指定的程序入口，如果沒寫，則為index，并輪詢查找index.js、index.node、index.json
21.devDependencies，開發(fā)模式下的依賴。

我們來看一下express的package.json文件：

{
    "name": "express",
        "description": "Sinatra inspired web development framework",
            "version": "3.3.4",
                "author": "TJ Holowaychuk <tj@vision-media.ca>",
                    "contributors": [
                        {
                            "name": "TJ Holowaychuk",
                            "email": "tj@vision-media.ca"
                        },
                        {
                            "name": "Aaron Heckmann",
                            "email": "aaron.heckmann+github@gmail.com"
                        },
                        {
                            "name": "Ciaran Jessup",
                            "email": "ciaranj@gmail.com"
                        },
                        {
                            "name": "Guillermo Rauch",
                            "email": "rauchg@gmail.com"
                        }
                    ],
                        "dependencies": {
        "connect": "2.8.4",
            "commander": "1.2.0",
                "range-parser": "0.0.4",
                    "mkdirp": "0.3.5",
                        "cookie": "0.1.0",
                            "buffer-crc32": "0.2.1",
                                "fresh": "0.1.0",
                                    "methods": "0.0.1",
                                        "send": "0.1.3",
                                            "cookie-signature": "1.0.1",
                                                "debug": "*"
    },
    "devDependencies": {
        "ejs": "*",
            "mocha": "*",
                "jade": "0.30.0",
                    "hjs": "*",
                        "stylus": "*",
                            "should": "*",
                                "connect-redis": "*",
                                    "marked": "*",
                                        "supertest": "0.6.0"
    }
    "keywords": [
        "express",
        "framework",
        "sinatra",
        "web",
        "rest",
        "restful",
        "router",
        "app",
        "api"
    ],
        "repository": "git://github.com/visionmedia/express",
            "main": "index",
                "bin": {
        "express": "./bin/express"
    },
    "scripts": {
        "prepublish": "npm prune",
            "test": "make test"
    },
    "engines": {
        "node": "*"
    }
}

npm常用功能

1.查看幫助，例如npm help <command>
2.安裝依賴包，npm install，當(dāng)然，還有全局安裝，也就是-g，它根據(jù)package.json描述的bin字段進(jìn)行配置，將實(shí)際腳本鏈接到與node可執(zhí)行文件相同的路徑下。這個(gè)目錄可以通過path.resolve(process.execPath, '..', '..', 'lib', 'node_modules');推算。如果node可執(zhí)行位置是/usr/local/bin/node，那么這個(gè)全局安裝的模塊就在/usr/local/lib/node_modules下。然后通過軟鏈接的方式，鏈接到node可執(zhí)行目錄下。另外，還可以進(jìn)行本地安裝，只需要指明要安裝的包的package.json所在的位置即可（位置可以使url、文件和文件夾）。還可以從非官方源安裝，執(zhí)行時(shí)需要增加后綴，--registry=http://registry.url，例如：npm install underscore -registry=http://registry.url如果使用過程幾乎都采用鏡像源安裝，可以通過命令修改默認(rèn)源:npm config set registry http://registry.url

npm鉤子命令

鉤子命令如下：

"scripts": {
"preinstall": "preinstall.js",
"install": "install.js",
"uninstall": "uninstall.js",
"test": "test.js"
}

例如，npm test會自動指向test目錄，并執(zhí)行測試。此時(shí)，會調(diào)用package.json中的測試命令，以此進(jìn)行測試。

包發(fā)布

筆者自己也寫過包，并發(fā)布，對，這個(gè)筆者不是樸靈，是我，是我，是我白昔月。名字為票市通對接云之訊短信接口，地址是：https://www.npmjs.com/package/bimartmessage，大家可以看看

1.編寫模塊
2.初始化package.js，可以用npm init快速進(jìn)行
3.注冊包倉庫賬戶，npm adduser
4.上傳包，npm publish <folder>
5.安裝包，npm install
6.管理包權(quán)限，npm owner，通過這個(gè)命令可以添加、刪除、查看幫助寫包的人。

npm owner ls <package name>
npm owner add <user> <package name>
npm owner rm <user> <package name>

分析包

使用 npm ls分析包。

使用 npm ls分析包

局域npm

這個(gè)可以看附錄D，不過，我不一定寫那部分筆記，如果寫了，再補(bǔ)充吧，先看看局域npm的結(jié)構(gòu)：

混合使用官方倉庫和局域倉庫的示意圖

另外，企業(yè)內(nèi)部使用局域npm，可以保證企業(yè)內(nèi)部的開發(fā)協(xié)助，杜絕企業(yè)內(nèi)部的程序大量的復(fù)制粘貼，造成代碼的不可維護(hù)。通過企業(yè)內(nèi)部的npm對代碼、對包進(jìn)行統(tǒng)一管理，從而提高項(xiàng)目的維護(hù)和使用效率。

npm潛在問題

安全問題，不用使用來路不明的包。如果大企業(yè)的話，一定要經(jīng)過安全部門的認(rèn)證才可以使用。
排查npm潛在問題的步驟如下：
1.具備良好的測試
2.具備良好的文檔，readme、api等
3.具備良好的測試覆蓋率
4.具備良好的編碼規(guī)范
5.其他各種手段......

前后端共用模塊

前端的瓶頸在于帶寬和瀏覽器兼容（需要網(wǎng)絡(luò)加載資源），后端的瓶頸在于cpu和內(nèi)存使用。因此，commonjs給出了AMD規(guī)范，Asynchronous Module Definition，也就是異步模塊定義。另外，阿里的玉伯還提出了CMD規(guī)范。

AMD規(guī)范

AMD規(guī)范定義模塊：define(id?, dependencies?, factory);
id和依賴是可選的，factory是實(shí)際的代碼，我們看個(gè)例子：

define(function () {
    var exports = {};
    exports.sayHello = function () {
        alert('Hello from module: ' + module.id);
    };
    return exports;
});

通過define包裝，進(jìn)行作用域隔離，避免污染全局變量或者全局命名空間。同時(shí)，結(jié)果通過返回方式導(dǎo)出。（node是require()加載導(dǎo)出）

CMD規(guī)范

我們來比較一下AMD和CMD

先看AMD

//依賴，也就是node中的require，需要在定義時(shí)引入，不是動態(tài)的。
define(['dep1', 'dep2'], function (dep1, dep2) {
return function () {};
});

再看CMD

define(factory);
//然后在需要依賴時(shí)，CMD動態(tài)引入
define(function(require, exports, module) {
// The module code goes here
//依賴通過require, exports, module傳遞給模塊，通過require()可以隨時(shí)動態(tài)引入需要的依賴
})

兼容多種模塊規(guī)范

為了讓同一個(gè)模塊可以運(yùn)行在前后端，開發(fā)者需要將類庫封裝在一個(gè)閉包內(nèi)（這個(gè)閉包可以貯存在內(nèi)存中，供反復(fù)使用），下面寫一個(gè)代碼，兼容node、AMD、CMD和常見瀏覽器環(huán)境。（應(yīng)用方面，比如計(jì)算錢的時(shí)候，就需要這樣的前后端統(tǒng)一的處理方式，還有就是日期等都是有需要的）

; (function (name, definition) {
    // 檢測上下文環(huán)境是否為AMD或者 CMD
    var hasDefine = typeof define === 'function',
        // 檢查上下文環(huán)境是否為Node
        hasExports = typeof module !== 'undefined' && module.exports;
    if (hasDefine) {
        // AMD環(huán)境或者 CMD環(huán)境
        define(definition);
    } else if (hasExports) {
        // 定義為普通Node模塊
        module.exports = definition();
    } else {
        // 將模塊的執(zhí)行結(jié)果掛在window變量中，在瀏覽器中this指向window對象
        this[name] = definition();
    }
})('hello', function () {
    var hello = function () { };
    return hello;
});