通過源碼解析 Node.js 中一個文件被 require 后所發生的故事

在 Node.js 中，要說如果有幾乎會在每一個文件都要用到的一個全局函數和一個全局對象，那應該是非 require 和 module.exports 莫屬了。它們是 Node.js 模塊機制的基石。大家在使用它們享受模塊化的好處時，有時也不禁好奇：

• 為何它倆使用起來像是全局函數/對象，卻在 global 對象下訪問不到它們？

'use strict'
console.log(require) // Function 
console.log(module) // Object 
console.log(global.require) // undefined
console.log(global.module) // undefined

• 這兩個“類全局”對象是在什么時候，怎么生成的？

• 當 require 一個目錄時，Node.js 是如何替我們找到具體該執行的文件的？

• 模塊內的代碼具體是以何種方式被執行的？

讓我們從 Node.js 項目的 lib/module.js 中的代碼里，細細看一番，一個文件被 require 后，具體發生的故事，從而來解答上面這些問題。

一個文件被 require 后所發生的故事

當我們在命令行中敲下：

node ./index.js

之后，src/node.cc 中的 node::LoadEnvironment 函數會被調用，在該函數內則會接著調用 src/node.js 中的代碼，并執行 startup 函數：

// src/node.js
// ...

function startup() {
  // ...
  Module.runMain();
}

// lib/module.js
// ...

Module.runMain = function() {
  // ...
  Module._load(process.argv[1], null, true);
  // ... 
};

所以，最后會執行到 Module._load(process.argv[1], null, true); 這條語句來加載模塊，不過其實，這個Module._load在require函數的代碼中也會被調用：

// lib/module.js
// ... 

Module.prototype.require = function(path) {
  assert(path, 'missing path');
  assert(typeof path === 'string', 'path must be a string');
  return Module._load(path, this, false);
};

所以說，當我們在命令行中敲下 node ./index.js，某種意義上，可以說隨后 Node.js 的表現即為立刻進行一次 require ， 即：

require('./index.js')

隨后的步驟就是 require 一個普通模塊了，讓我們繼續往下看，Module._load 方法做的第一件事，便是調用內部方法 Module._resolveFilename ，而該內部方法在進行了一些參數預處理后，最終會調用 Module._findPath 方法，來得到需被導入模塊的完整路徑，讓我們從代碼中來總結出它的路徑分析規則：

// lib/module.js
// ...

Module._findPath = function(request, paths) {
  // 優先取緩存
  var cacheKey = JSON.stringify({request: request, paths: paths});
  if (Module._pathCache[cacheKey]) {
    return Module._pathCache[cacheKey];
  }

  // ...
  for (var i = 0, PL = paths.length; i < PL; i++) {
    if (!trailingSlash) { 
      const rc = stat(basePath);
      if (rc === 0) {  // 若是文件.
        filename = toRealPath(basePath);
      } else if (rc === 1) {  // 若是目錄
        filename = tryPackage(basePath, exts);
      }

      if (!filename) {
        // 帶上 .js .json .node 后綴進行嘗試
        filename = tryExtensions(basePath, exts);
      }
    }

    if (!filename) {
      filename = tryPackage(basePath, exts);
    }

    if (!filename) {
      // 嘗試 index.js index.json index.node
      filename = tryExtensions(path.resolve(basePath, 'index'), exts);
    }

    if (filename) {
      // ...
      Module._pathCache[cacheKey] = filename;
      return filename;
    }
  }
  return false;
};

function tryPackage(requestPath, exts) {
  var pkg = readPackage(requestPath); // 獲取 package.json 中 main 屬性的值

  // ...
  return tryFile(filename) || tryExtensions(filename, exts) ||
         tryExtensions(path.resolve(filename, 'index'), exts);
}

代碼中的條件判斷十分清晰，讓我們來總結一下：

• 若模塊的路徑不以 / 結尾，則先檢查該路徑是否真實存在：

  • 若存在且為一個文件，則直接返回文件路徑作為結果。

  • 若存在且為一個目錄，則嘗試讀取該目錄下的 package.json 中 main 屬性所指向的文件路徑。

    • 判斷該文件路徑是否存在，若存在，則直接作為結果返回。

    • 嘗試在該路徑后依次加上 .js ， .json 和 .node 后綴，判斷是否存在，若存在則返回加上后綴后的路徑。

    • 嘗試在該路徑后依次加上 index.js ， index.json 和 index.node，判斷是否存在，若存在則返回拼接后的路徑。

  • 若仍未返回，則為指定的模塊路徑依次加上 .js ， .json 和 .node 后綴，判斷是否存在，若存在則返回加上后綴后的路徑。

• 若模塊以 / 結尾，則嘗試讀取該目錄下的 package.json 中 main 屬性所指向的文件路徑。

  • 判斷該文件路徑是否存在，若存在，則直接作為結果返回。

  • 嘗試在該路徑后依次加上 .js ， .json 和 .node 后綴，判斷是否存在，若存在則返回加上后綴后的路徑。

  • 嘗試在該路徑后依次加上 index.js ， index.json 和 index.node，判斷是否存在，若存在則返回拼接后的路徑。

• 若仍未返回，則為指定的模塊路徑依次加上 index.js ， index.json 和 index.node，判斷是否存在，若存在則返回拼接后的路徑。

在取得了模塊的完整路徑后，便該是執行模塊了，我們以執行 .js 后綴的 JavaScript 模塊為例。首先 Node.js 會通過 fs.readFileSync 方法，以 UTF-8 的格式，將 JavaScript 代碼以字符串的形式讀出，傳遞給內部方法 module._compile，在這個內部方法里，則會調用 NativeModule.wrap 方法，將我們的模塊代碼包裹在一個函數中：

// src/node.js
// ...

NativeModule.wrap = function(script) {
  return NativeModule.wrapper[0] + script + NativeModule.wrapper[1];
};

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

所以，這便解答了我們之前提出的，在 global 對象下取不到它們的問題，因為它們是以包裹在外的函數的參數的形式傳遞進來的。所以順便提一句，我們平常在文件的頂上寫的 use strict ，其實最終聲明的并不是 script-level 的嚴格模式，而都是 function-level 的嚴格模式。

最后一步， Node.js 會使用 vm.runInThisContext 執行這個拼接完畢的字符串，取得一個 JavaScript 函數，最后帶著對應的對象參數執行它們，并將賦值在 module.exports 上的對象返回：

// lib/module.js
// ...

Module.prototype._compile = function(content, filename) {
  // ...

  var compiledWrapper = runInThisContext(wrapper, {
    filename: filename,
    lineOffset: 0,
    displayErrors: true
  });

  // ...
  const args = [this.exports, require, this, filename, dirname];

  const result = compiledWrapper.apply(this.exports, args);
  // ...
};

至此，一個同步的 require 操作便圓滿結束啦。

最后

由于 Node.js 中的模塊導入和 ES6 規范中的不同，它的導入過程是同步的。所以實現起來會方便許多，代碼量同樣也不多。十分推薦大家閱讀一下完整的實現。

參考：

• https://github.com/nodejs/node/blob/v5.x/lib/module.js

• https://github.com/nodejs/node/blob/v5.x/src/node.js