Node中怎么引入一個模塊

這篇文章將為大家詳細講解有關Node中怎么引入一個模塊，文章內容質量較高，因此小編分享給大家做個參考，希望大家閱讀完這篇文章后對相關知識有一定的了解。

module wrapper

當我們使用 node 中寫一個模塊時，實際上該模塊被一個函數包裹，如下所示:

(function(exports, require, module, __filename, __dirname) {    // 所有的模塊代碼都被包裹在這個函數中    const fs = require('fs')    const add = (x, y) => x + y   module.exports = add  });

因此在一個模塊中自動會注入以下變量：

•  exports

•  require

•  module

•  __filename

•  __dirname

module

調試最好的辦法就是打印，我們想知道 module 是何方神圣，那就把它打印出來！

const fs = require('fs')  const add = (x, y) => x + y  module.exports = add  console.log(module)

•  module.id: 如果是 . 代表是入口模塊，否則是模塊所在的文件名，可見如下的 koa

•  module.exports: 模塊的導出

koa module

module.exports 與 exports

  ?    `module.exports` 與 `exports` 有什么關系？[1]    ?

從以下源碼中可以看到 module wrapper 的調用方 module._compile 是如何注入內置變量的，因此根據源碼很容易理解一個模塊中的變量：

•  exports: 實際上是 module.exports 的引用

•  require: 大多情況下是 Module.prototype.require

•  module

•  __filename

•  __dirname: path.dirname(__filename) 

// <node_internals>/internal/modules/cjs/loader.js:1138  Module.prototype._compile = function(content, filename) {    // ...    const dirname = path.dirname(filename);    const require = makeRequireFunction(this, redirects);    let result;    // 從中可以看出：exports = module.exports    const exports = this.exports;    const thisValue = exports;    const module = this;    if (requireDepth === 0) statCache = new Map();    if (inspectorWrapper) {      result = inspectorWrapper(compiledWrapper, thisValue, exports,                                require, module, filename, dirname);    } else {      result = compiledWrapper.call(thisValue, exports, require, module,                                    filename, dirname);    }    // ...  }

require

通過 node 的 REPL 控制臺，或者在 VSCode 中輸出 require 進行調試，可以發現 require 是一個極其復雜的對象

require

從以上 module wrapper 的源碼中也可以看出 require 由 makeRequireFunction 函數生成，如下

// <node_internals>/internal/modules/cjs/helpers.js:33  function makeRequireFunction(mod, redirects) {    const Module = mod.constructor;    let require;    if (redirects) {      // ...    } else {      // require 實際上是 Module.prototype.require      require = function require(path) {        return mod.require(path);      };    }    function resolve(request, options) { // ... }    require.resolve = resolve;    function paths(request) {      validateString(request, 'request');      return Module._resolveLookupPaths(request, mod);    }    resolve.paths = paths;    require.main = process.mainModule;    // Enable support to add extra extension types.    require.extensions = Module._extensions;    require.cache = Module._cache;    return require;  }

  ?    關于 require 更詳細的信息可以去參考官方文檔: Node API: require[2]    ?

require(id)

require 函數被用作引入一個模塊，也是平常最常見最常用到的函數

// <node_internals>/internal/modules/cjs/loader.js:1019  Module.prototype.require = function(id) {    validateString(id, 'id');    if (id === '') {      throw new ERR_INVALID_ARG_VALUE('id', id,                                      'must be a non-empty string');    }    requireDepth++;    try {      return Module._load(id, this, /* isMain */ false);    } finally {      requireDepth--;    }  }

而 require 引入一個模塊時，實際上通過 Module._load 載入，大致的總結如下：

1. 鴻蒙官方戰略合作共建——HarmonyOS技術社區

2.  如果 Module._cache 命中模塊緩存，則直接取出 module.exports，加載結束

3.  如果是 NativeModule，則 loadNativeModule 加載模塊，如 fs、http、path 等模塊，加載結束

4.  否則，使用 Module.load 加載模塊，當然這個步驟也很長，下一章節再細講 

// <node_internals>/internal/modules/cjs/loader.js:879  Module._load = function(request, parent, isMain) {    let relResolveCacheIdentifier;    if (parent) {      // ...    }    const filename = Module._resolveFilename(request, parent, isMain);    const cachedModule = Module._cache[filename];    // 如果命中緩存，直接取緩存    if (cachedModule !== undefined) {      updateChildren(parent, cachedModule, true);      return cachedModule.exports;    }    // 如果是 NativeModule，加載它    const mod = loadNativeModule(filename, request);    if (mod && mod.canBeRequiredByUsers) return mod.exports;    // Don't call updateChildren(), Module constructor already does.    const module = new Module(filename, parent);    if (isMain) {      process.mainModule = module;      module.id = '.';    }    Module._cache[filename] = module;    if (parent !== undefined) { // ... }    let threw = true;    try {      if (enableSourceMaps) {        try {          // 如果不是 NativeModule，加載它          module.load(filename);        } catch (err) {          rekeySourceMap(Module._cache[filename], err);          throw err; /* node-do-not-add-exception-line */        }      } else {        module.load(filename);      }      threw = false;    } finally {      // ...    }    return module.exports;  };

require.cache

「當代碼執行 require(lib) 時，會執行 lib 模塊中的內容，并作為一份緩存，下次引用時不再執行模塊中內容」。

這里的緩存指的就是 require.cache，也就是上一段指的 Module._cache

// <node_internals>/internal/modules/cjs/loader.js:899  require.cache = Module._cache;

這里有個小測試:

  ?    有兩個文件: index.js 與 utils.js。utils.js 中有一個打印操作，當 index.js 引用 utils.js 多次時，utils.js 中的打印操作會執行幾次。代碼示例如下    ?

「index.js」

// index.js  // 此處引用兩次  require('./utils')  require('./utils')

「utils.js」

// utils.js  console.log('被執行了一次')

「答案是只執行了一次」，因此 require.cache，在 index.js 末尾打印 require，此時會發現一個模塊緩存

// index.js  require('./utils')  require('./utils')  console.log(require)

那回到本章剛開始的問題：

  ?    如何不重啟應用熱加載模塊呢？    ?

答：「刪掉 Module._cache」，但同時會引發問題，如這種 一行 delete require.cache 引發的內存泄漏血案[3]

所以說嘛，這種黑魔法大幅修改核心代碼的東西開發環境玩一玩就可以了，千萬不要跑到生產環境中去，畢竟黑魔法是不可控的。

關于Node中怎么引入一個模塊就分享到這里了，希望以上內容可以對大家有一定的幫助，可以學到更多知識。如果覺得文章不錯，可以把它分享出去讓更多的人看到。