Node中如何引入一個(gè)模塊及其細(xì)節(jié)
在 node 環(huán)境中，有兩個(gè)內(nèi)置的全局變量無(wú)需引入即可直接使用，并且無(wú)處不見(jiàn)，它們構(gòu)成了 nodejs 的模塊體系: module 與 require。以下是一個(gè)簡(jiǎn)單的示例
- const fs = require('fs')
- const add = (x, y) => x + y
- module.exports = add
雖然它們?cè)谄匠Ｊ褂弥袃H僅是引入與導(dǎo)出模塊，但稍稍深入，便可見(jiàn)乾坤之大。在業(yè)界可用它們做一些比較 trick 的事情，雖然我不大建議使用這些黑科技，但稍微了解還是很有必要。
- 如何在不重啟應(yīng)用時(shí)熱加載模塊？如 require 一個(gè) json 文件時(shí)會(huì)產(chǎn)生緩存，但是重寫文件時(shí)如何 watch
- 如何通過(guò)不侵入代碼進(jìn)行打印日志
- 循環(huán)引用會(huì)產(chǎn)生什么問(wèn)題？
module wrapper
當(dāng)我們使用 node 中寫一個(gè)模塊時(shí)，實(shí)際上該模塊被一個(gè)函數(shù)包裹，如下所示:
- (function(exports, require, module, __filename, __dirname) {
- // 所有的模塊代碼都被包裹在這個(gè)函數(shù)中
- const fs = require('fs')
- const add = (x, y) => x + y
- module.exports = add
- });
因此在一個(gè)模塊中自動(dòng)會(huì)注入以下變量：
- exports
- require
- module
- __filename
- __dirname
module
調(diào)試最好的辦法就是打印，我們想知道 module 是何方神圣，那就把它打印出來(lái)！
- const fs = require('fs')
- const add = (x, y) => x + y
- module.exports = add
- console.log(module)
- module.id: 如果是 . 代表是入口模塊，否則是模塊所在的文件名，可見(jiàn)如下的 koa
- module.exports: 模塊的導(dǎo)出
koa module
module.exports 與 exports
❝ `module.exports` 與 `exports` 有什么關(guān)系？[1] ❞
從以下源碼中可以看到 module wrapper 的調(diào)用方 module._compile 是如何注入內(nèi)置變量的，因此根據(jù)源碼很容易理解一個(gè)模塊中的變量：
- exports: 實(shí)際上是 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
通過(guò) node 的 REPL 控制臺(tái)，或者在 VSCode 中輸出 require 進(jìn)行調(diào)試，可以發(fā)現(xiàn) require 是一個(gè)極其復(fù)雜的對(duì)象
require
從以上 module wrapper 的源碼中也可以看出 require 由 makeRequireFunction 函數(shù)生成，如下
- // <node_internals>/internal/modules/cjs/helpers.js:33
- function makeRequireFunction(mod, redirects) {
- const Module = mod.constructor;
- let require;
- if (redirects) {
- // ...
- } else {
- // require 實(shí)際上是 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;
- }
❝ 關(guān)于 require 更詳細(xì)的信息可以去參考官方文檔: Node API: require[2] ❞
require(id)
require 函數(shù)被用作引入一個(gè)模塊，也是平常最常見(jiàn)最常用到的函數(shù)
- // <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 引入一個(gè)模塊時(shí)，實(shí)際上通過(guò) Module._load 載入，大致的總結(jié)如下：
- 如果 Module._cache 命中模塊緩存，則直接取出 module.exports，加載結(jié)束
- 如果是 NativeModule，則 loadNativeModule 加載模塊，如 fs、http、path 等模塊，加載結(jié)束
- 否則，使用 Module.load 加載模塊，當(dāng)然這個(gè)步驟也很長(zhǎng)，下一章節(jié)再細(xì)講
- // <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
「當(dāng)代碼執(zhí)行 require(lib) 時(shí)，會(huì)執(zhí)行 lib 模塊中的內(nèi)容，并作為一份緩存，下次引用時(shí)不再執(zhí)行模塊中內(nèi)容」。
這里的緩存指的就是 require.cache，也就是上一段指的 Module._cache
- // <node_internals>/internal/modules/cjs/loader.js:899
- require.cache = Module._cache;
這里有個(gè)小測(cè)試:
❝ 有兩個(gè)文件: index.js 與 utils.js。utils.js 中有一個(gè)打印操作，當(dāng) index.js 引用 utils.js 多次時(shí)，utils.js 中的打印操作會(huì)執(zhí)行幾次。代碼示例如下 ❞
「index.js」
- // index.js
- // 此處引用兩次
- require('./utils')
- require('./utils')
「utils.js」
- // utils.js
- console.log('被執(zhí)行了一次')
「答案是只執(zhí)行了一次」，因此 require.cache，在 index.js 末尾打印 require，此時(shí)會(huì)發(fā)現(xiàn)一個(gè)模塊緩存
- // index.js
- require('./utils')
- require('./utils')
- console.log(require)
那回到本章剛開(kāi)始的問(wèn)題：
❝ 如何不重啟應(yīng)用熱加載模塊呢？ ❞
答：「刪掉 Module._cache」，但同時(shí)會(huì)引發(fā)問(wèn)題，如這種 一行 delete require.cache 引發(fā)的內(nèi)存泄漏血案[3]
所以說(shuō)嘛，這種黑魔法大幅修改核心代碼的東西開(kāi)發(fā)環(huán)境玩一玩就可以了，千萬(wàn)不要跑到生產(chǎn)環(huán)境中去，畢竟黑魔法是不可控的。
總結(jié)
- 模塊中執(zhí)行時(shí)會(huì)被 module wrapper 包裹，并注入全局變量 require 及 module 等
- module.exports 與 exports 的關(guān)系實(shí)際上是 exports = module.exports
- require 實(shí)際上是 module.require
- require.cache 會(huì)保證模塊不會(huì)被執(zhí)行多次
- 不要使用 delete require.cache 這種黑魔法
