在 node 環(huán)境中,有兩個(gè)內(nèi)置的全局變量無需引入即可直接使用,并且無處不見,它們構(gòu)成了 nodejs 的模塊體系: module 與 require。以下是一個(gè)簡單的示例
const fs = require('fs')
const add = (x, y) => x + y
module.exports = add
雖然它們在平常使用中僅僅是引入與導(dǎo)出模塊,但稍稍深入,便可見乾坤之大。在業(yè)界可用它們做一些比較 trick 的事情,雖然我不大建議使用這些黑科技,但稍微了解還是很有必要。
- 如何在不重啟應(yīng)用時(shí)熱加載模塊?如 require 一個(gè) json 文件時(shí)會產(chǎn)生緩存,但是重寫文件時(shí)如何 watch
- 如何通過不侵入代碼進(jìn)行打印日志
- 循環(huán)引用會產(chǎ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è)模塊中自動會注入以下變量:
- exports
- require
- module
- __filename
- __dirname
module
調(diào)試最好的辦法就是打印,我們想知道 module 是何方神圣,那就把它打印出來!
const fs = require('fs')
const add = (x, y) => x + y
module.exports = add
console.log(module)
- module.id: 如果是 . 代表是入口模塊,否則是模塊所在的文件名,可見如下的 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
通過 node 的 REPL 控制臺,或者在 VSCode 中輸出 require 進(jìn)行調(diào)試,可以發(fā)現(xiàn) require 是一個(gè)極其復(fù)雜的對象
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è)模塊,也是平常最常見最常用到的函數(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í)際上通過 Module._load 載入,大致的總結(jié)如下:
- 如果 Module._cache 命中模塊緩存,則直接取出 module.exports,加載結(jié)束
- 如果是 NativeModule,則 loadNativeModule 加載模塊,如 fs、http、path 等模塊,加載結(jié)束
- 否則,使用 Module.load 加載模塊,當(dāng)然這個(gè)步驟也很長,下一章節(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í),會執(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è)小測試:
? 有兩個(gè)文件: index.js 與 utils.js。utils.js 中有一個(gè)打印操作,當(dāng) index.js 引用 utils.js 多次時(shí),utils.js 中的打印操作會執(zhí)行幾次。代碼示例如下 ?
「index.js」
// index.js
// 此處引用兩次
require('./utils')
require('./utils')
「utils.js」
// utils.js
console.log('被執(zhí)行了一次')
「答案是只執(zhí)行了一次」,因此 require.cache,在 index.js 末尾打印 require,此時(shí)會發(fā)現(xiàn)一個(gè)模塊緩存
// index.js
require('./utils')
require('./utils')
console.log(require)
那回到本章剛開始的問題:
? 如何不重啟應(yīng)用熱加載模塊呢? ?
答:「刪掉 Module._cache」,但同時(shí)會引發(fā)問題,如這種 一行 delete require.cache 引發(fā)的內(nèi)存泄漏血案[3]
所以說嘛,這種黑魔法大幅修改核心代碼的東西開發(fā)環(huán)境玩一玩就可以了,千萬不要跑到生產(chǎn)環(huán)境中去,畢竟黑魔法是不可控的。
總結(jié)
- 模塊中執(zhí)行時(shí)會被 module wrapper 包裹,并注入全局變量 require 及 module 等
- module.exports 與 exports 的關(guān)系實(shí)際上是 exports = module.exports
- require 實(shí)際上是 module.require
- require.cache 會保證模塊不會被執(zhí)行多次
- 不要使用 delete require.cache 這種黑魔法