【 js 模塊加載 】【源碼學習】深入學習模塊化加載（node.js 模塊源碼）

文章提綱：

　　第一部分：介紹模塊規范及之間區別

　　第二部分：以 node.js 實現模塊化規范 源碼，深入學習。

 

一、模塊規范

說到模塊化加載，就不得先說一說模塊規范。模塊規范是用來約束每個模塊，讓其必須按照一定的格式編寫。AMD,CMD,CommonJS 是目前最常用的三種模塊化書寫規范。 

1、AMD（Asynchronous Module Definition）：異步模塊定義，所謂異步是指模塊和模塊的依賴可以被異步加載，他們的加載不會影響它后面語句的運行。有效避免了采用同步加載方式中導致的頁面假死現象。AMD代表：RequireJS。

 

它主要有兩個接口：define 和 require。define 是模塊開發者關注的方法，而 require 則是模塊使用者關注的方法。 

      1.1、define() 函數：

define(id?, dependencies?, factory);
//id ：可選參數，它指的是模塊的名字。
//dependencies：可選參數，定義中模塊所依賴模塊的數組。
//factory：模塊初始化要執行的函數或對象

需要注意的是，dependencies有多少個元素，factory就有多少個傳參，位置一一對應。

使用栗子：

define("alpha", ["require", "exports", "beta"], function (require, exports, beta) {  
    exports.verb = function() {            
        return beta.verb();            
        //Or:
        //return require("beta").verb();        
    }    
});

 

      1.2、require() 函數

require([module], callback);
//module：一個數組，里面的成員就是要加載的模塊.
//callback：模塊加載成功之后的回調函數。

需要注意的是 ，module 有多少個元素，callback 就有多少個傳參，位置一一對應。

使用的栗子:

require(["a","b","c"],function(a,b,c){
    //code here
});

具體的使用詳細,大家可以去官網學習： https://github.com/amdjs/amdjs-api/wiki/AMD-(%E4%B8%AD%E6%96%87%E7%89%88)

 

2、CMD（Common Module Definition）：通用模塊定義，本質上也是異步的加載模塊，采用的是懶加載方式即按需加載。CMD代表：SeaJS。

 

它主要有一個接口：define 是模塊開發者關注的方法。

define(factory);
//factory：模塊初始化要執行的函數或對象，為函數時，表示是模塊的構造方法。
//執行該構造方法，可以得到模塊向外提供的接口。
//factory 方法在執行時，默認會傳入三個參數：require、exports 和 module。
//其中require用來獲取其他模塊提供的接口，exports用來向外提供模塊接口，module是一個對象，上面存儲了與當前模塊相關聯的一些屬性和方法。

使用的栗子： 

define(function(require, exports, module) {
    var a = require('./a')
    a.doSomething()
    // 此處略去 100 行
    var b = require('./b') // 依賴可以就近書寫
    b.doSomething()
    // …
    // 對外提供 doSomething 方法
    exports.doSomething = function() {};
});

而調用CMD編寫的模塊的方法是:

seajs.use("a")//調用a模塊
//這里就設計到SeaJS的使用了：
//- 引入sea.js的庫
//- 如何變成模塊？
//      - define
//- 如何調用模塊？
//      -sea.js.use
//- 如何依賴模塊？
//      -require

具體的使用詳細，建議大家可以去官網學習： https://github.com/seajs/seajs/issues/242

 

 

3、CommonJS ：采用同步加載模塊的方式，也就是說只有加載完成，才能執行后面的操作。CommonJS 代表：Node 應用中的模塊，通俗的說就是你用 npm 安裝的模塊。

它使用 require 引用和加載模塊，exports 定義和導出模塊，module 標識模塊。使用 require 時需要去讀取並執行該文件，然后返回 exports 導出的內容。

 //定義模塊 math.js
 var random=Math.random()*10;
 function printRandom(){
     console.log(random)
 }

 function printIntRandom(){
     console.log(Math.floor(random))
 }
 //模塊輸出
 module.exports={
     printRandom:printRandom,
     printIntRandom:printIntRandom
 }
 //加載模塊 math.js
 var math=require('math')
 //調用模塊提供的方法
 math.printIntRandom()
 math.printRandom()

 

4、模塊規范之間的區別

     A、首先說一下 CommonJS與其它兩種的區別：CommonJS采用的就是同步加載方式，而其它兩種都是異步的。

　　　舉個栗子：

commonJS中：

var math = require('math');
math.add(2, 3);

第二行 math.add(2, 3)，在第一行 require('math') 之后運行，因此必須等 math.js 加載完成。也就是說，如果加載時間很長，整個應用就會停在那里等。

AMD中：

require(['math'], function (math) {
　　math.add(2, 3);
});

console.log("222");

這個是不會阻遏后面語句的執行的，等到什么時候 math 模塊加載出來進行回調函數就可以了。

PS：由於 Node.js 主要用於服務器編程，模塊文件一般都已經存在於本地硬盤，所以加載起來比較快，不用考慮非同步加載的方式，所以 CommonJS 規范比較適用。但是，如果是瀏覽器環境，要從服務器端加載模塊，這時就必須采用非同步模式，因此瀏覽器端一般采用 AMD 規范。 

 

     B、再說一下 AMD 和 CMD 的區別：

最主要的區別就是執行模塊的機制大不一樣：

SeaJS(CMD) 對模塊的態度是懶執行, 而 RequireJS(AMD) 對模塊的態度是預執行。

SeaJS 只會在真正需要使用(依賴)模塊時才執行該模塊。執行模塊的順序也是嚴格按照模塊在代碼中出現(require)的順序。

而 RequireJS 會先盡早地執行(依賴)模塊, 相當於所有的 require 都被提前了, 而且模塊執行的順序也不一定100%按照順序。 

　　

如果大家沒有明白，可以參考文章： https://www.douban.com/note/283566440/  有栗子，更形象。 

 

二、深入學習模塊化加載

 

下面從源碼深入了解一下所謂的模塊加載系統到底是如何運作的。

因為現在工作中用的大部分模塊都是 node_modules 也就是 CommonJS 模塊規范，所以我就以 node.js 實現模塊的源碼來分析：

 

前提知識：

      知識點一：主入口文件 即主模塊。在 require 方法中引用的 Module._load(path,parent,isMain)，第三個參數 isMain 表示是不是主入口文件。對於 foo.js 文件，如果通過 node foo.js 運行則為 true，但如果通過 require('./foo') 運行則為 false。

     知識點二：涉及到的模塊類型:

　　　　　1、核心模塊：指的 lib 目錄下排除 lib/internal 文件下的模塊。是那些被編譯進 Node 的二進制模塊，它們被預置在 Node 中，提供 Node 的基本功能，如fs、http、https等。核心模塊使用 C/C++ 實現，外部使用 JS 封裝。要加載核心模塊，直接在代碼文件中使用 require() 方法即可，參數為模塊名稱，Node 將自動從核心模塊文件夾中進行加載。注意加載核心模塊只能用模塊名。核心模塊擁有最高的加載優先級，即使已經有了一個同名的第三方模塊，核心模塊也會被優先加載。

　　　　　2、內部模塊：指的是 lib/internal 文件夾下的模塊，這些模塊僅僅供 Node.js 核心的內部使用，不能被外部使用。

 

  

通常我們在使用一個模塊的時候在 js 中都是這樣引用的：

var math = require('math');
math.add(2, 3);

從 require 方法本身是如何實現的入手，一步一步看：（代碼全部來自 node.js [https://github.com/nodejs/node] 源碼）

 

require 方法封裝在 node 源碼中的 lib 文件夾里的 module.js 中

// Loads a module at the given file path. Returns that module's
// `exports` property.
// 給定一個模塊目錄，返回該模塊的 exports 屬性
Module.prototype.require = function(path) {
  // assert() 頭部引入，主要用於斷言，如果表達式不符合預期，就拋出一個錯誤。
  // assert方法接受兩個參數，當第一個參數對應的布爾值為true時，不會有任何提示，返回undefined。
  // 當第一個參數對應的布爾值為false時，會拋出一個錯誤，該錯誤的提示信息就是第二個參數設定的字符串。
  assert(path, 'missing path');  //斷言是否有path
  assert(typeof path === 'string', 'path must be a string'); //斷言 path是否是個字符串

  return Module._load(path, this, /* isMain */ false);  //require方法主要是為了引出_load方法。
  //_load函數三個參數： path 當前加載的模塊名稱,parent 父親模塊，其實是誰導入了該模塊，
  // /* isMain */ false  是不是主入口文件
};

require 中調用了 Module._load()方法：

// Check the cache for the requested file.
// 1. If a module already exists in the cache: return its exports object.
// 2. If the module is native: call `NativeModule.require()` with the
//    filename and return the result.
// 3. Otherwise, create a new module for the file and save it to the cache.
//    Then have it load  the file contents before returning its exports
//    object.
// 從緩存中查找所要加載的模塊
// 1. 如果一個模塊已經存在於緩存中：直接返回它的exports對象
// 2. 如果模塊是一個本地模塊，調用'NativeModule.require()'方法，filename作為參數，並返回結果
// 3. 否則，使用這個文件創建一個新模塊並把它加入緩存中。在加載它只會返回exports對象。
// _load函數三個參數： path 當前加載的模塊名稱,parent 父親模塊，/* isMain */ false  是不是主入口文件
Module._load = function(request, parent, isMain) { 
  if (parent) {
      //頭部引入了 Module._debug = util.debuglog('module');const debug = Module._debug;
    // 這個方法用來打印出調試信息,具體可以看 https://chyingp.gitbooks.io/nodejs/%E6%A8%A1%E5%9D%97/util.html
    debug('Module._load REQUEST %s parent: %s', request, parent.id); 

  }

  // 找到當前的需要解析的文件名
  var filename = Module._resolveFilename(request, parent, isMain);

  //如果已經有的緩存，直接返回緩存的exports
  var cachedModule = Module._cache[filename];
  if (cachedModule) {
    return cachedModule.exports;
  }

  //如果模塊是一個內部模塊，調用內部方法'NativeModule.require()'方法，filename作為參數，並返回結果
  if (NativeModule.nonInternalExists(filename)) {
    debug('load native module %s', request);
    return NativeModule.require(filename);
  }

  //創建一個新模塊
  var module = new Module(filename, parent);

  //是否為主模塊，
  if (isMain) {
    //主模塊的話，需要將當前的module賦值給process.mainModule
    process.mainModule = module;
    //主模塊的id特殊的賦值為"."
    module.id = '.';
  }

  //並把新模塊加入緩存中
  Module._cache[filename] = module;

  //嘗試導入模塊的操作
 tryModuleLoad(module, filename);

  // 返回新創建模塊中的exports,也就是暴露在外面的方法屬性等。
  return module.exports;
};

Module._load 中調用了 Module._resolveFilename() 方法

// 負責具體filename的文件查找
// 參數 request 當前加載的模塊名稱,parent 父親模塊，/* isMain */ false  是不是主入口文件
Module._resolveFilename = function(request, parent, isMain) { 

  //NativeModule用於管理js模塊，頭部引入的。
  //NativeModule.nonInternalExists()用來判斷是否是原生模塊且不是內部模塊，
  //所謂內部模塊就是指 lib/internal 文件目錄下的模塊，像fs等。
  //滿足 是原生模塊且不是內部模塊,則直接返回 當前加載的模塊名稱request。
  if (NativeModule.nonInternalExists(request)) {
    return request;
  }

  // Module._resolveLookupPaths()函數返回一個數組[id , paths], 
  // paths是一個 可能 包含這個模塊的文件夾路徑(絕對路徑)數組
  var paths = Module._resolveLookupPaths(request, parent, true);

  // look up the filename first, since that's the cache key.
  // 確定哪一個路徑為真，並且添加到緩存中
  var filename = Module._findPath(request, paths, isMain);

  // 如果沒有找到模塊，報錯
  if (!filename) {
    var err = new Error(`Cannot find module '${request}'`);
    err.code = 'MODULE_NOT_FOUND';
    throw err;
  }

  // 找到模塊則直接返回
  return filename;
};

Module._resolveFilename 調用了 Module._resolveLookupPaths() 方法 和 Module._findPath() 方法。

這兩個方法主要是對模塊路徑的查找，這里要說一下 node 模塊路徑解析，方便對下面兩個函數的理解，大家可以對照着理解。

根據require函數的參數形式的不同，比如說直接引一個文件名 require("moduleA")，或者是路徑require("./moduleA")等,查找方式會有一些變化：

從 Y 路徑的模塊 require(X) 
1. 如果 X 是一個核心模塊，    
    a. 返回核心模塊 //核心模塊是指node.js下lib的內容    
    b. 結束 
2. 如果 X 是以 './' 或 '/' 或 '../' 開頭    
    a. 加載文件(Y + X)    
    b. 加載目錄(Y + X) 
3. 加載Node模塊(X, dirname(Y)) // 導入一個NODE_MODULE，返回 
4. 拋出 "未找到" // 上述都沒找到，直接排出沒找到的異常。 
 加載文件(X) 
1. 如果 X 是一個文件，加載 X 作為 JavaScript 文本。結束 
2. 如果 X.js 是一個文件，加載 X.js 作為 JavaScript 文本。結束 
3. 如果 X.json 是一個文件，解析 X.json 成一個 JavaScript 對象。結束 
4. 如果 X.node 是一個文件，加載 X.node 作為二進制插件。結束 

加載目錄(X) 
1. 如果 X/package.json 是一個文件，    
    a. 解析 X/package.json，查找 "main" 字段    
    b. let M = X + (json main 字段)    
    c. 加載文件(M) 
2. 如果 X/index.js 是一個文件，加載  X/index.js 作為 JavaScript 文本。結束 
3. 如果 X/index.json 是一個文件，解析 X/index.json 成一個 JavaScript 對象。結束 
4. 如果 X/index.node 是一個文件，加載  X/index.node 作為二進制插件。結束 

加載Node模塊(X, START) 
1. let DIRS=NODE_MODULES_PATHS(START) //得到 node_module 文件目錄 
2. for each DIR in DIRS: // 遍歷所有的路徑 直到找到 x ，x 可能是 文件或者是目錄    
    a. 加載文件(DIR/X)    
    b. 加載目錄(DIR/X) 

NODE_MODULES_PATHS(START) //具體NODE_MODULES文件目錄算法 
1. let PARTS = path split(START) 
2. let I = count of PARTS - 1 
3. let DIRS = [] 
4. while I >= 0,    
    a. if PARTS[I] = "node_modules" CONTINUE    
    b. DIR = path join(PARTS[0 .. I] + "node_modules")    
    c. DIRS = DIRS + DIR    
    d. let I = I - 1 5. return DIRS

 

1、Module._resolveLookupPaths() 方法

// 'index.' character codes
var indexChars = [ 105, 110, 100, 101, 120, 46 ];
var indexLen = indexChars.length;
//_resolveLookupPaths() 方法用來查找模塊，返回一個數組，數組第一項為模塊名稱即request，數組第二項返回一個可能包含這個模塊的文件夾路徑數組
//
//處理了如下幾種情況：
// 1、是原生模塊且不是內部模塊
// 2、如果路徑不以"./" 或者'..'開頭或者只有一個字符串，即是引用模塊名的方式，即require('moduleA');
//   2.1以 '/' 為前綴的模塊是文件的絕對路徑。 例如，require('/home/marco/foo.js') 會加載 /home/marco/foo.js 文件。
//   2.2以 './' 為前綴的模塊是相對於調用 require() 的文件的。 也就是說，circle.js 必須和 foo.js 在同一目錄下以便於 require('./circle') 找到它。
//   2.3當沒有以 '/'、'./' 或 '../' 開頭來表示文件時，這個模塊必須是一個核心模塊或加載自 node_modules 目錄。
Module._resolveLookupPaths = function(request, parent, newReturn) { //request 當前加載的模塊名稱,parent 父親模塊

  //NativeModule用於管理js模塊，頭部引入的。
  //NativeModule.nonInternalExists()用來判斷是否是原生模塊且不是內部模塊，所謂內部模塊就是指 lib/internal 文件目錄下的模塊，像fs等。
  if (NativeModule.nonInternalExists(request)) {
    debug('looking for %j in []', request);

    //滿足 是原生模塊且不是內部模塊，也就是說是node.js下lib文件夾下的模塊，
    //但不包含lib/internal 文件目錄下的模塊，並且newReturn 為true，則返回null ，
    //如果newReturn 為false 則返回［request, []］。
    return (newReturn ? null : [request, []]);
  }

  // Check for relative path
  // 檢查相關路徑
  // 如果路徑不以"./"或者'..'開頭或者只有一個字符串，即是引用模塊名的方式，即require('moduleA');
  if (request.length < 2 ||
      request.charCodeAt(0) !== 46/*.*/ ||
      (request.charCodeAt(1) !== 46/*.*/ &&
       request.charCodeAt(1) !== 47/*/*/)) {
      //全局變量,在Module._initPaths 函數中賦值的變量,modulePaths記錄了全局加載依賴的根目錄
    var paths = modulePaths; 

    // 設置一下父親的路徑，其實就是誰導入了當前模塊
    if (parent) {
      if (!parent.paths)
        paths = parent.paths = [];
      else
        paths = parent.paths.concat(paths);
    }

    // Maintain backwards compat with certain broken uses of require('.')
    // by putting the module's directory in front of the lookup paths.
    // 如果只有一個字符串，且是 .
    if (request === '.') {
      if (parent && parent.filename) {
        paths.unshift(path.dirname(parent.filename));
      } else {
        paths.unshift(path.resolve(request));
      }
    }

    debug('looking for %j in %j', request, paths);

    //直接返回
    return (newReturn ? (paths.length > 0 ? paths : null) : [request, paths]);
  }

  // with --eval, parent.id is not set and parent.filename is null
  // 處理父親模塊為空的情況
  if (!parent || !parent.id || !parent.filename) {
    // make require('./path/to/foo') work - normally the path is taken
    // from realpath(__filename) but with eval there is no filename
    // 生成新的目錄， 在系統目錄 modulePaths，當前目錄 和 "node_modules" 作為候選的路徑
    var mainPaths = ['.'].concat(Module._nodeModulePaths('.'), modulePaths);

    debug('looking for %j in %j', request, mainPaths);
    //直接返回
    return (newReturn ? mainPaths : [request, mainPaths]);
  }

  // Is the parent an index module?
  // We can assume the parent has a valid extension,
  // as it already has been accepted as a module.
  // 處理父親模塊是否為index模塊，即 path/index.js 或者 X/index.json等 帶有index字樣的module
  const base = path.basename(parent.filename); // path.basename()返回路徑中的最后一部分
  var parentIdPath;
  if (base.length > indexLen) {
    var i = 0;

    //檢查 引入的模塊名中是否有 "index." 字段，如果有, i === indexLen。
    for (; i < indexLen; ++i) {
      if (indexChars[i] !== base.charCodeAt(i))
        break;
    }

    // 匹配 "index." 成功，查看是否有多余字段以及剩余部分的匹配情況
    if (i === indexLen) {
      // We matched 'index.', let's validate the rest
      for (; i < base.length; ++i) {
        const code = base.charCodeAt(i);

        // 如果模塊名中有  除了 _, 0-9,A-Z,a-z 的字符 則跳出，繼續下一次循環
        if (code !== 95/*_*/ &&
            (code < 48/*0*/ || code > 57/*9*/) &&
            (code < 65/*A*/ || code > 90/*Z*/) &&
            (code < 97/*a*/ || code > 122/*z*/))
          break;
      }


      if (i === base.length) {
        // Is an index module
        parentIdPath = parent.id;
      } else {
        // Not an index module
        parentIdPath = path.dirname(parent.id); //path.dirname() 返回路徑中代表文件夾的部分
      }
    } else {
      // Not an index module
      parentIdPath = path.dirname(parent.id);
    }
  } else {
    // Not an index module
    parentIdPath = path.dirname(parent.id);
  }

  //拼出絕對路徑
  //path.resolve([from ...], to) 將 to 參數解析為絕對路徑。
  //eg:path.resolve('/foo/bar', './baz') 輸出'/foo/bar/baz'
  var id = path.resolve(parentIdPath, request);  

  // make sure require('./path') and require('path') get distinct ids, even
  // when called from the toplevel js file
  // 確保require('./path')和require('path')兩種形式的，獲得不同的 ids
  if (parentIdPath === '.' && id.indexOf('/') === -1) {
    id = './' + id;
  }

  debug('RELATIVE: requested: %s set ID to: %s from %s', request, id,
        parent.id);
  //path.dirname() 返回路徑中代表文件夾的部分
  var parentDir = [path.dirname(parent.filename)]; 

  debug('looking for %j in %j', id, parentDir);

  // 當我們以"./" 等方式require時，都是以當前引用他的模塊，也就是父親模塊為對象路徑的
  return (newReturn ? parentDir : [id, parentDir]);
};

 

2、Module._findPath() 方法

var warned = false;
//_findPath用於從可能的路徑中確定哪一個路徑為真，並且添加到緩存中
//參數request 當前加載的模塊名稱,
//paths ，Module._resolveLookupPaths()函數返回一個數組[id , paths],即模塊可能在的所有路徑，
// /* isMain */ false  是不是主入口文件
Module._findPath = function(request, paths, isMain) {

  //path.isAbsolute()判斷參數 path 是否是絕對路徑。
  if (path.isAbsolute(request)) {  
    paths = [''];
  } else if (!paths || paths.length === 0) {
    return false;
  }


  var cacheKey = request + '\x00' +
                (paths.length === 1 ? paths[0] : paths.join('\x00'));
  var entry = Module._pathCache[cacheKey];

  //判斷是否在緩存中，如果有則直接返回
  if (entry)
    return entry;

  //如果不在緩存中，則開始查找
  var exts;
  // 當前加載的模塊名稱大於0位並且最后一位是 ／ ，即是否有后綴的目錄斜杠
  var trailingSlash = request.length > 0 &&
                      request.charCodeAt(request.length - 1) === 47/*/*/;

  // For each path
  // 循環每一個可能的路徑paths
  for (var i = 0; i < paths.length; i++) {

    // Don't search further if path doesn't exist
    // 如果路徑存在就繼續執行，不存在就繼續檢驗下一個路徑 stat 獲取路徑狀態
    const curPath = paths[i];
    if (curPath && stat(curPath) < 1) continue;
    var basePath = path.resolve(curPath, request); //生成絕對路徑
    var filename;

    //stat 頭部定義的函數，用來獲取路徑狀態，判斷路徑類型，是文件還是文件夾
    var rc = stat(basePath);
    //如果沒有后綴的目錄斜杠，那么就有可能是文件或者是文件夾名
    if (!trailingSlash) {
      // 若是文件
      if (rc === 0) {  // File.

        // 如果是使用模塊的符號路徑而不是真實路徑，並且不是主入口文件
        if (preserveSymlinks && !isMain) {  
          filename = path.resolve(basePath);
        } else {
          filename = toRealPath(basePath); //獲取當前執行文件的真實路徑
        }

      // 若是目錄
      } else if (rc === 1) {  // Directory.
        if (exts === undefined)
          //目錄中是否存在 package.json
          //通過package.json文件,返回相應路徑
          exts = Object.keys(Module._extensions);
        filename = tryPackage(basePath, exts, isMain);
      }

      // 如果嘗試了上面都沒有得到filename 匹配所有擴展名進行嘗試，是否存在
      if (!filename) {
        // try it with each of the extensions
        if (exts === undefined)
          exts = Object.keys(Module._extensions);
        // 該模塊文件加上后綴名js .json .node進行嘗試，是否存在
        filename = tryExtensions(basePath, exts, isMain);
      }
    }

    // 如果仍然沒有得到filename，並且路徑類型是文件夾
    if (!filename && rc === 1) {  // Directory.
      if (exts === undefined)
        // 目錄中是否存在 package.json
        // 通過package.json文件,返回相應路徑
        exts = Object.keys(Module._extensions);
      filename = tryPackage(basePath, exts, isMain);
    }

    // 如果仍然沒有得到filename，並且路徑類型是文件夾
    if (!filename && rc === 1) {  // Directory.
      // try it with each of the extensions at "index"
      // 是否存在目錄名 + index + 后綴名
      // 嘗試 index.js index.json index.node
      if (exts === undefined)
        exts = Object.keys(Module._extensions);

      //tryExtensions()頭部定義方法，用來檢查文件加上js node json后綴是否存在
      filename = tryExtensions(path.resolve(basePath, 'index'), exts, isMain);
    }


    if (filename) {
      // Warn once if '.' resolved outside the module dir
      if (request === '.' && i > 0) {
        if (!warned) {
          warned = true;
          process.emitWarning(
            'warning: require(\'.\') resolved outside the package ' +
            'directory. This functionality is deprecated and will be removed ' +
            'soon.',
            'DeprecationWarning', 'DEP0019');
        }
      }

      // 將找到的文件路徑存入返回緩存，然后返回
      Module._pathCache[cacheKey] = filename;
      return filename;
    }
  }

  // 所以從這里可以看出，對於具體的文件的優先級：
  // 1. 具體文件。
  // 2. 加上后綴。
  // 3. package.json
  // 4  index加上后綴
  // 可能的路徑以當前文件夾，nodejs系統文件夾和node_module中的文件夾為候選，以上述順序找到任意一個，
  // 就直接返回

  // 沒有找到文件，返回false
  return false;
};

 

Module._load 中還調用了 tryModuleLoad() 方法

function tryModuleLoad(module, filename) {
  var threw = true;

  //try catch一下，如果裝載失敗，就會從cache中將這個模塊刪除。
  try {

    //做真正的導入模塊的操作
    module.load(filename);
    threw = false;
  } finally {
    if (threw) {
      delete Module._cache[filename];
    }
  }
}

 

tryModuleLoad() 中調用了 Module.prototype.load() 方法

// Given a file name, pass it to the proper extension handler.
// 指定一個文件名，導入模塊，調用適當擴展處理函數，當前主要是js，json，和node
Module.prototype.load = function(filename) {
  debug('load %j for module %j', filename, this.id);

  assert(!this.loaded); //斷言 確保當前模塊沒有被載入
  this.filename = filename; // 賦值當前模塊的文件名

  // Module._nodeModulePaths主要決定paths參數的值的方法。獲取node_modules文件夾所在路徑。
  // path.dirname() 方法返回一個 path 的目錄名 path.dirname('/foo/bar/baz/asdf/quux')
  // 返回: '/foo/bar/baz/asdf'
  this.paths = Module._nodeModulePaths(path.dirname(filename));

  //當前文件的后綴
  var extension = path.extname(filename) || '.js';

  //如果沒有后綴，默認為 .js
  if (!Module._extensions[extension]) extension = '.js';

  //根據不同的后綴，執行不同的函數
  Module._extensions[extension](this, filename);
  this.loaded = true;
};

 

Module.prototype.load() 中調用了 Module._nodeModulePaths() 和 Module._extensions 方法

1、Module._nodeModulePaths() 根據操作系統的不同，返回不同的函數

//path 模塊的默認操作會根據 Node.js 應用程序運行的操作系統的不同而變化。 
//比如，當運行在 Windows 操作系統上時，path 模塊會認為使用的是 Windows 風格的路徑。
//例如，對 Windows 文件路徑 C:\temp\myfile.html 使用 path.basename() 函數，
//運行在 POSIX 上與運行在 Windows 上會產生不同的結果：
//在 POSIX 上:
//path.basename('C:\\temp\\myfile.html');
// 返回: 'C:\\temp\\myfile.html'
//
// 在 Windows 上:
//path.basename('C:\\temp\\myfile.html');
// 返回: 'myfile.html'
//
// 以下就是根據不同的操作系統返回不同的路徑格式 ，具體可以了解http://nodejs.cn/api/path.html
//
//
// Module._nodeModulePaths主要決定paths參數的值的方法。獲取node_modules文件夾所在路徑。
// 'node_modules' character codes reversed
var nmChars = [ 115, 101, 108, 117, 100, 111, 109, 95, 101, 100, 111, 110 ];
var nmLen = nmChars.length;
if (process.platform === 'win32') {
  // 'from' is the __dirname of the module.
  Module._nodeModulePaths = function(from) {
    // guarantee that 'from' is absolute.
    from = path.resolve(from);

    // note: this approach *only* works when the path is guaranteed
    // to be absolute.  Doing a fully-edge-case-correct path.split
    // that works on both Windows and Posix is non-trivial.

    // return root node_modules when path is 'D:\\'.
    // path.resolve will make sure from.length >=3 in Windows.
    if (from.charCodeAt(from.length - 1) === 92/*\*/ &&
        from.charCodeAt(from.length - 2) === 58/*:*/)
      return [from + 'node_modules'];

    const paths = [];
    var p = 0;
    var last = from.length;
    for (var i = from.length - 1; i >= 0; --i) {
      const code = from.charCodeAt(i);
      // The path segment separator check ('\' and '/') was used to get
      // node_modules path for every path segment.
      // Use colon as an extra condition since we can get node_modules
      // path for dirver root like 'C:\node_modules' and don't need to
      // parse driver name.
      if (code === 92/*\*/ || code === 47/*/*/ || code === 58/*:*/) {
        if (p !== nmLen)
          paths.push(from.slice(0, last) + '\\node_modules');
        last = i;
        p = 0;
      } else if (p !== -1) {
        if (nmChars[p] === code) {
          ++p;
        } else {
          p = -1;
        }
      }
    }

    return paths;
  };
} else { // posix
  // 'from' is the __dirname of the module.
  Module._nodeModulePaths = function(from) {
    // guarantee that 'from' is absolute.
    from = path.resolve(from);
    // Return early not only to avoid unnecessary work, but to *avoid* returning
    // an array of two items for a root: [ '//node_modules', '/node_modules' ]
    if (from === '/')
      return ['/node_modules'];

    // note: this approach *only* works when the path is guaranteed
    // to be absolute.  Doing a fully-edge-case-correct path.split
    // that works on both Windows and Posix is non-trivial.
    const paths = [];
    var p = 0;
    var last = from.length;
    for (var i = from.length - 1; i >= 0; --i) {
      const code = from.charCodeAt(i);
      if (code === 47/*/*/) {
        if (p !== nmLen)
          paths.push(from.slice(0, last) + '/node_modules');
        last = i;
        p = 0;
      } else if (p !== -1) {
        if (nmChars[p] === code) {
          ++p;
        } else {
          p = -1;
        }
      }
    }

    // Append /node_modules to handle root paths.
    paths.push('/node_modules');

    return paths;
  };
}

 

2、Module._extensions 方法

// 根據不同的文件類型，三種后綴，Node.js會進行不同的處理和執行
// 對於.js的文件會，先同步讀取文件，然后通過module._compile解釋執行。
// 對於.json文件的處理，先同步的讀入文件的內容，無異常的話直接將模塊的exports賦值為json文件的內容
// 對於.node文件的打開處理，通常為C/C++文件。
// Native extension for .js
Module._extensions['.js'] = function(module, filename) {
  // 同步讀取文件
  var content = fs.readFileSync(filename, 'utf8');

  // internalModule.stripBOM（）剝離 utf8 編碼特有的BOM文件頭，
  // 然后通過module._compile解釋執行
  module._compile(internalModule.stripBOM(content), filename);
};


// Native extension for .json
Module._extensions['.json'] = function(module, filename) {
  // 同步的讀入文件的內容
  var content = fs.readFileSync(filename, 'utf8');
  try {
    // internalModule.stripBOM（）剝離 utf8 編碼特有的BOM文件頭，
    // 然后將模塊的exports賦值為json文件的內容
    module.exports = JSON.parse(internalModule.stripBOM(content));
  } catch (err) {
    // 異常處理
    err.message = filename + ': ' + err.message;
    throw err;
  }
};


//Native extension for .node
Module._extensions['.node'] = function(module, filename) {
  // 對於.node文件的打開處理，通常為C/C++文件。
  return process.dlopen(module, path._makeLong(filename));
};

 

針對 .js 后綴的，在 Module._extensions 還調用了 module._compile() 方法

// Resolved path to process.argv[1] will be lazily placed here
// (needed for setting breakpoint when called with --debug-brk)
var resolvedArgv;
// Run the file contents in the correct scope or sandbox. Expose
// the correct helper variables (require, module, exports) to
// the file.
// Returns exception, if any.
// 此方法用於模塊的編譯。
// 參數content 主要是模塊js文件的主要內容,filename 是js文件的文件名
Module.prototype._compile = function(content, filename) {
  // Remove shebang
  // Shebang（也稱為 Hashbang ）是一個由井號和嘆號構成的字符序列 #!
  var contLen = content.length;
  if (contLen >= 2) {
    // 如果content 開頭有Shebang
    if (content.charCodeAt(0) === 35/*#*/ &&
        content.charCodeAt(1) === 33/*!*/) {
      if (contLen === 2) {
        // Exact match
        content = '';
      } else {
        // Find end of shebang line and slice it off
        // 找到以shebang開頭的句子的結尾，並將其分開,留下剩余部分 賦值給content
        var i = 2;
        for (; i < contLen; ++i) {
          var code = content.charCodeAt(i);
          if (code === 10/*\n*/ || code === 13/*\r*/)
            break;
        }
        if (i === contLen)
          content = '';
        else {
          // Note that this actually includes the newline character(s) in the
          // new output. This duplicates the behavior of the regular expression
          // that was previously used to replace the shebang line
          content = content.slice(i);
        }
      }
    }
  }

  // create wrapper function
  // Module.wrap頭部引入，主要用來給content內容包裝頭尾，類似於
//   (function (exports, require, module, __filename, __dirname) {
//         －－－－－模塊源碼 content－－－－－
//    });
  var wrapper = Module.wrap(content);

// 包裝好的文本就可以送到vm中執行了，這部分就應該是v8引擎的事情,
// runInThisContext將被包裝后的源字符串轉成可執行函數,runInThisContext的作用，類似eval
  var compiledWrapper = vm.runInThisContext(wrapper, {
    filename: filename,
    lineOffset: 0,
    displayErrors: true
  });

  var inspectorWrapper = null;
  // 處理debug模式，
  if (process._debugWaitConnect && process._eval == null) {
    if (!resolvedArgv) {
      // we enter the repl if we're not given a filename argument.
      if (process.argv[1]) {
        resolvedArgv = Module._resolveFilename(process.argv[1], null, false);
      } else {
        resolvedArgv = 'repl';
      }
    }

    // Set breakpoint on module start
    if (filename === resolvedArgv) {
      delete process._debugWaitConnect;
      inspectorWrapper = getInspectorCallWrapper();
      if (!inspectorWrapper) {
        const Debug = vm.runInDebugContext('Debug');
        Debug.setBreakPoint(compiledWrapper, 0, 0);
      }
    }
  }

  // 獲取當前的文件的路徑
  var dirname = path.dirname(filename);

  //生成require方法
  var require = internalModule.makeRequireFunction(this);

  //依賴模塊
  var depth = internalModule.requireDepth;
  if (depth === 0) stat.cache = new Map();
  var result;

  //直接調用content經過包裝后的wrapper函數，將module模塊中的exports，生成的require，
  //this也就是新創建的module，filename, dirname作為參數傳遞給模塊
  //類似於
  //(function (exports, require, module, __filename, __dirname) {
//       －－－－－模塊源碼 content－－－－－
//  })( this.exports, require, this, filename, dirname);
  // 這就是為什么我們可以直接在module文件中，直接訪問exports, module, require函數的原因
  if (inspectorWrapper) {
    result = inspectorWrapper(compiledWrapper, this.exports, this.exports,
                              require, this, filename, dirname);
  } else {
    result = compiledWrapper.call(this.exports, this.exports, require, this,
                                  filename, dirname);
  }
  if (depth === 0) stat.cache = null;
  return result;
};

 

Module.prototype._compile 中調用了 Module.wrap 這個方法就是用了給 content 包裝的主要函數， 它來自頭部的引用:

//Module.wrapper和Module.wrap的方法寫在下面，
//給傳入進去的script也就是咱們的content --js文件內容套了一個殼，使其最后變成類似於如下的樣子：
//
//(function (exports, require, module, __filename, __dirname) {
//         －－－－－模塊源碼－－－－－
// });
//
// NativeModule.wrap = function(script) {
//     return NativeModule.wrapper[0] + script + NativeModule.wrapper[1];
// };

// NativeModule.wrapper = [
//     '(function (exports, require, module, __filename, __dirname) { ',
//     '\n});'
// ];
Module.wrapper = NativeModule.wrapper;
Module.wrap = NativeModule.wrap;

 

module.js 中還定義了一些其它的方法，在這里沒有寫出來，像 stat、readPackage、tryPackage、頭部引入的一些方法等，大家可以 從我的github（ https://github.com/JiayiLi/node.js-module）上 clone 下來，放到 IDE 里跟着調用順序一步一步的看，都有詳細的注釋。

 

根據函數調用順序，總體梳理一下

 

                                                                       （圖一） 

現在咱們再看這個圖，梳理一下剛才的代碼，就清晰多了。 

 

                                                    （圖二）

最后，還有個問題 lib 目錄下的模塊文件，像 module.js 也沒有定義 require ，module，exports 這些變量，他們是如何使用的呢？

這是因為在引入核心模塊的時候也進行了頭尾包裝的過程。這里就要提到 lib/internal 文件夾下的 bootstrap_node.js，屬於 node 啟動文件。

 

在 bootstrap_node.js 中定義了一個 NativeModule 對象，用於加載核心模塊，如 module.js、http.js 等即 lib 文件夾下的 排除 lib/internal 目錄下的 js 模塊。

 

在這個 NativeModule 對象中也定義了 require 方法，compile 方法、wrap 方法(用於包裝頭尾)等 都和上面的 module.js 中的相應的方法意思是一樣的，可以下載源碼了解一下。

結論就是，node.js 通過 NativeModule 來對 module.js 、fs.js 等核心模塊進行包裝加載，所以它們里面也可以使用 require。 

 

最后還是建議從我的 github（ https://github.com/JiayiLi/node.js-module）上 clone 下來 ，放到 ide 里，按照函數的調用一個一個看，看的過程中也對照着圖一、圖二理清思路。 

 

 

 

 

－－－－－－－－－－－－－ 學會的知識也要時常review －－－－－－－－－－－－

 

 

 

Node.js 中文文檔

http://nodejs.cn/api/

 

學習並感謝

https://www.douban.com/note/283566440/

http://blog.csdn.net/leoleocs/article/details/50245677

http://www.ruanyifeng.com/blog/2012/10/asynchronous_module_definition.html