• nodejs模組語法與開閉原則
• nodejs模組的底層實現

 一、nodejs模組語法與開閉原則

關於nodejs模組我在之前的兩篇部落格中都有涉及，但都沒有對nodejs模組的底層做做任何探討，但是為了使相關內容更方便檢視比對理解，這裡還是先引入一下之前兩篇部落格的連線：

js模組化入門與commonjs解析與應用

ES6入門十二：Module（模組化）

1.1 exports、module.exports、require()實現模組匯出匯入：

 1 //示例一：匯出原始值資料
 2 //a.js--用於匯出資料
 3 let a = 123;
 4 module.exports.a=a;
 5 //inde.js--用於匯入a模組的資料
 6 let aModule = require('./a.js');
 7 console.log(aModule.a); //123
 8 
 9 //示例二：匯出引用值資料
10 //a.js--同上
11 function foo(val){ 
12     console.log(val);
13 }
14 module.exports.foo = foo;
15 //index.js--同上
16 let aModule = require('./a.js');
17 let str = "this is 'index' module"
18 aModule.foo(str); //this is 'index' module
19 
20 //示例三：匯出混合資料
21 a.js--同上
22 let a = 123;
23 function foo(val){ 
24     console.log(val);
25 }
26 module.exports = {
27     a:a,
28     foo:foo
29 }
30 //inde.js--同上
31 let aModule = require('./a.js');
32 let str = "this is 'index' module"
33 console.log(aModule.a);//123
34 aModule.foo(str); //this is 'index' module

在上面這些示例中，沒有演示exports的匯出，暫時可以把它看作與同等於module.exports，例如：

 1 //a.js -- 匯出模組
 2 let a = 123;
 3 function foo(val){ 
 4     console.log(val);
 5 }
 6 exports.a = a;
 7 exports.foo = foo;
 8 
 9 //inde.js -- 引用模組a
10 let aModule = require('./a.js');
11 let str = "this is 'index' module"
12 console.log(aModule.a);//123
13 aModule.foo(str); //this is 'index' module

但是使用exports匯出模組不能這麼寫：

 1 //a.js
 2 let a = 123;
 3 function foo(val){ 
 4     console.log(val);
 5 }
 6 exports = {
 7     a:a,
 8     foo:foo
 9 }
10 
11 //index.js
12 let aModule = require('./a.js');
13 let str = "this is 'index' module"
14 console.log(aModule);// {} -- 一個空物件

至於為什麼不能這麼寫，暫時不在這裡闡述，下一節關於nodejs模組底層實現會具體的分析介紹，這裡先來介紹nodejs模組的一個設計思想。

1.2 nodejs模組的開閉原則設計實現

1 //a.js -- 匯出模組
2 let num = 123;
3 let str = "this is module 'a'";
4 exports.a = a;
5 
6 //index.js -- 引用模組a
7 let aModule = require('./a.js');
8 console.log(aModule.num);//123
9 console.log(aModule.str);//undefined

這裡你會發現只有被exports執行了匯出的num成員才能被正常匯出，而str成員沒有被執行匯出，在依賴a.js模組的index.js中是不能引用到a.js模組中的str成員。可能你會說這不是很正常嗎？都沒有匯出怎麼引用呢？

不錯，這是一個非常正常情況，因為語法就告訴了我們，要想引用一個模組的成員就必須先在被引用的模組中匯出該成員。然而這裡要討論的當然不會是匯出與引用這個問題，而是模組給我實現了一個非常友好的設計，假設我現在在a.js中有成員str，在index.js模組中也有成員str，這回衝突嗎？顯然是不會的，即使在a.js中匯出str並且在index.js中引用a.js模組，因為index.js要使用a.js模組的成員str，需要使用接收模組變數aModule.str來使用。

 1 //a.js
 2 let num = 123;
 3 let str = "this is module 'a'";
 4 exports.num = num;
 5 exports.str = str;
 6 
 7 //index.js
 8 let aModule = require('./a.js');
 9 let str = "this is module 'index'"
10 console.log(aModule.num);//123
11 console.log(aModule.str);//this is module 'a'
12 console.log(str);//this is module 'index'

基於開閉原則的設計方式，封閉可以讓模組的內部實現隱藏起來，開放又可以友好的實現模組之間的相互依賴，這相對於之前我們常用的回撥函式解決方案，程式設計變得更清晰，程式碼複用變得更靈活，更關鍵的是還解決了js中一個非常棘手的問題——命名衝突問題，上面的示例就是最好的證明。這裡需要丟擲一個問題，看示例：

1 //下面這種寫法有什麼問題？
2 //a.js
3 let num = 123;
4 module.exports = num;
5 
6 //index.js
7 let aModule = require('./a.js');
8 let str = "this is module 'index'"
9 console.log(aModule);//123

這種寫法不會報錯，也能正常達到目前的需求，如果從能解決目前的功能需求角度來說，它沒錯。但是開閉原則的重要思想就是讓模組保持相對封閉，又有更好的拓展性，這樣寫顯然不合適，比如就上面的程式碼寫完上線以後，業務又出現了一個新的需求需要a.js模組匯出一個成員str，這時候顯然需要同時更改a.js模組和index.js模組，即使新需求不需要index.js來實現也是需要改的。所以維持模組的開閉原則是良好的編碼風格。

 二、nodejs模組的底層實現原理

2.1 module.exports與exports的區別：

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

//然後在控制檯直接執行a.js模組
node a.js

實際上它們是沒有區別的，那為什麼在之前的exports不能直接等於一個物件，而module.exports可以呢？這關乎於js的引用值指向問題：

 當export被賦值一個物件時，就發生了一下變化：

這時候我們可以確定node不會匯出exports，因為前面的示例已經說明了這一點，但是值得我們繼續思考的是，node模組是依據module.exports、exports、還是它們指向的初始物件呢？這裡你肯定會說是module.exports，因為前面已經有示例是module.exports指向一個新的物件被成功匯出，但是我並不覺得前面那些示例能說服我，比如下面這種情況：

 1 //a.js模組
 2 let num = 123;
 3 function foo(val){
 4     console.log(val);
 5 }
 6 module.exports = {
 7     num:num
 8 }
 9 exports = {
10     foo:foo
11 }
12 //index.js模組
13 let aModule = require('./a.js');
14 console.log(aModule);//這裡會打印出什麼？

我們現不測試也不猜測，先通過下面的示圖來看下現在的a.js模組中module.exports、exports、以及它們兩初始指向的空物件的關係圖：

 這時候我們來看一下index.js執行會輸出什麼？

{ num: 123 }

所以從這個結果可以看出，最後require()最後匯入的是被引用模組的module.exports。探討到這裡的時候並沒有到達node模組的終點，我們這裡module.exports、exports、require()是從哪裡來的？node系統內建變數？還是別的？

2.2 node模組的底層實現原理

這部分的內容其實也沒有太多可以說的，就前面提出來的問題其實有一個方式就可以讓你一目瞭然，只需要在一個js檔案中編寫一下程式碼，然後使用node執行這個js檔案就可以了：

1 console.log(require);      // 一個方法
2 console.log(module);       //  一個物件
3 console.log(exports);      //  一個空物件
4 console.log(__dirname);    //  當前模組所在路徑
5 console.log(__filename);   //  當前檔案的路徑

 這時因為node模組實際上底層是被放到一個立即執行函式內（不要在乎xyz這個名稱，因為我也不知道node底層到底用的什麼名稱），這些變數其實就是這個函式的引數，這個函式大概是一下形式：

1 function xyz(module.exports,require,module,__filename,__dirname){
2     //...
3     //  這裡就是我們在模組中寫入的程式碼
4     //...
5     return module.exports;
6 }

通過上面的推斷就可以得到下面這樣的結果：

1 console.log(module.exports == arguments[0]);//true
2 console.log(require == arguments[1]);//true
3 console.log(module == arguments[2]);//true
4 console.log(__filename == arguments[3]);//true
5 console.log(__dirname == arguments[4]);//true

通過執行這段列印程式碼也確實可以得到這樣的結果，到這裡又有一個值得我們關注的內容，就是每個模組的module引數：

 1 console.log(module);
 2 Module {
 3     id: '.',//當前模組的id都是'.'，在後面的parent和children裡面的模組物件上的id就是的對應模組的filename
 4     exports: {},//這裡是模組匯出物件
 5     parent: null,//這裡是當前模組被那些模組引用的模組物件列表，意思是當前模組作為那些模組的父級模組
 6     filename:''，//這裡是當前檔案路徑的絕對路徑
 7     loaded: false,//模組載入狀態，如果在模組內部輸出module物件它永遠都會是false，因為只有這個模組載入完成之後才會被修改成true
 8     children: [
 9         // 這裡是引用模組module物件列表，意思是當前模組作為了那些模組的子模組
10     ],
11     paths:[ 
12         // 這裡是外部模組包的路徑列表，從最近的路徑（模組所在同級路徑）到系統盤路徑所有的node_modules資料夾路徑
13      ] 
14     }

到這裡有可能你還會問為什麼底層實現裡面只有module.exports，沒有export，這個解釋起來真的費勁，下面這一行程式碼幫你搞定：

let exports = module.exports;

這篇部落格主要介紹了node模組的內部內容，並未就node模組基於commonjs規範做任何介紹，是因為在之前的部落格中已經有了非常全面的解析，詳細參考部落格開始時的連線，關於node模組載入相關內容也是在那篇博