探索 Node.js 原始碼，詳解cjs 模組的載入過程
- 青灯夜游轉載
- 2022-09-07 20:13:532189瀏覽
相信大家都知道如何在Node 中載入一個模組：
const fs = require('fs');
const express = require('express');
const anotherModule = require('./another-module');
沒錯，require就是載入cjs 模組的API，但V8 本身是沒有cjs 模組系統的，所以node 是怎麼透過require找到模組並且載入的呢？ 【相關教學推薦：nodejs影片教學】
我們今天將對 Node.js 原始碼進行探索，深入理解 cjs 模組的載入過程。 我們閱讀的node 程式碼版本為v17.x：
- git 頭 ：881174e016d6c27b20c70111e6eae2296b6c6293
- #1%連結：github.com/#nojs/node…
內建模組為了知道
require 的工作邏輯，我們需要先了解內建模組是如何被載入到node 中的(諸如'fs'，'path'，'child_process'，其中也包括一些無法被使用者引用的內部模組)，準備好程式碼之後，我們首先要從node 啟動開始閱讀。
node 的main 函數在[src/node_main.cc](https://github.com/nodejs/node/blob/881174e016d6c27b20c70111e6eae2296b6c6293/src/node_main#Lccc/node_main#Lccc/node_main#Lcc/node_main#Lcc/node_main#Lcc/node_main#Lcc/node_main#Lcc/node_main#Lccc/node_main#Lccc/node_main#Lccc/node_main#Lcc/node_main#Lccc/node_main#Lcc/node_main#Lcc #[node::Start](https://github.com/nodejs/node/blob/881174e016d6c27b20c70111e6eae2296b6c6293/src/node.cc#L1134)##no# 來啟動一個#rrde 實例：這裡建立一個#rrde 實例來啟動一個#rde 實例來啟動一個#了事件循環，並且創建了一個NodeMainInstance 的實例main_instance 並且呼叫了它的Run
int Start(int argc, char** argv) {
InitializationResult result = InitializeOncePerProcess(argc, argv);
if (result.early_return) {
return result.exit_code;
}
{
Isolate::CreateParams params;
const std::vector<size_t>* indices = nullptr;
const EnvSerializeInfo* env_info = nullptr;
bool use_node_snapshot =
per_process::cli_options->per_isolate->node_snapshot;
if (use_node_snapshot) {
v8::StartupData* blob = NodeMainInstance::GetEmbeddedSnapshotBlob();
if (blob != nullptr) {
params.snapshot_blob = blob;
indices = NodeMainInstance::GetIsolateDataIndices();
env_info = NodeMainInstance::GetEnvSerializeInfo();
}
}
uv_loop_configure(uv_default_loop(), UV_METRICS_IDLE_TIME);
NodeMainInstance main_instance(¶ms,
uv_default_loop(),
per_process::v8_platform.Platform(),
result.args,
result.exec_args,
indices);
result.exit_code = main_instance.Run(env_info);
}
TearDownOncePerProcess();
return result.exit_code;
}
方法中呼叫[CreateMainEnvironment](https://github.com/nodejs/node/blob/881174e016d6c27b20c70111e6eae2296b6c6293/src/node_main_instance. ##建立Environment 物件env 並呼叫其[RunBootstrapping](https://github.com/nodejs/node/blob/881174e016d6c27b20c70111e6eae296/nob. L398) 方法：<pre class="brush:php;toolbar:false">int NodeMainInstance::Run(const EnvSerializeInfo* env_info) {
Locker locker(isolate_);
Isolate::Scope isolate_scope(isolate_);
HandleScope handle_scope(isolate_);
int exit_code = 0;
DeleteFnPtr<Environment, FreeEnvironment> env =
CreateMainEnvironment(&exit_code, env_info);
CHECK_NOT_NULL(env);
Context::Scope context_scope(env->context());
Run(&exit_code, env.get());
return exit_code;
}</pre>這裡的
[internal/bootstrap/loaders.js](https://github.com/nodejs/node/blob/881174e016d6c27b20c70111e6eae2296b6c6293/lib/internal/bootstrap/loaders.模組的[nativeModulerequire](https://github.com/nodejs/node/blob/881174e016d6c27b20c70111e6eae2296b6c6293/lib/internal/bootstrap/loaders#jsL3332)，用於載入的內建函數，332）用於載入的函數，332)。 [internalBinding](https://github.com/nodejs/node/blob/881174e016d6c27b20c70111e6eae2296b6c6293/lib/internal/bootstrap/loaders.js#L##C 模組，用於載入的內建#C 模組，載入中的內建#. NativeModule](https://github.com/nodejs/node/blob/881174e016d6c27b20c70111e6eae2296b6c6293/lib/internal/bootstrap/loaders.js#L191) 則是內建的小型模組來模組。
Environment* CreateEnvironment(
IsolateData* isolate_data,
Local<Context> context,
const std::vector<std::string>& args,
const std::vector<std::string>& exec_args,
EnvironmentFlags::Flags flags,
ThreadId thread_id,
std::unique_ptr<InspectorParentHandle> inspector_parent_handle) {
Isolate* isolate = context->GetIsolate();
HandleScope handle_scope(isolate);
Context::Scope context_scope(context);
// TODO(addaleax): This is a much better place for parsing per-Environment
// options than the global parse call.
Environment* env = new Environment(
isolate_data, context, args, exec_args, nullptr, flags, thread_id);
#if HAVE_INSPECTOR
if (inspector_parent_handle) {
env->InitializeInspector(
std::move(static_cast<InspectorParentHandleImpl*>(
inspector_parent_handle.get())->impl));
} else {
env->InitializeInspector({});
}
#endif
if (env->RunBootstrapping().IsEmpty()) {
FreeEnvironment(env);
return nullptr;
}
return env;
}
要注意的是，這個 require 函數只會被用於內建模組的加載，用戶模組的載入並不會用到它。 （這也是為什麼我們透過列印require('module')._cache 可以看到所有使用者模組，卻看不到fs 等內建模組的原因，因為兩者的載入和快取維護方式並不一樣）。 使用者模組
[NodeMainInstance::Run](https://github .com/nodejs/node/blob/881174e016d6c27b20c70111e6eae2296b6c6293/src/node_main_instance.cc#L127) 函式：
MaybeLocal<Value> Environment::RunBootstrapping() {
EscapableHandleScope scope(isolate_);
CHECK(!has_run_bootstrapping_code());
if (BootstrapInternalLoaders().IsEmpty()) {
return MaybeLocal<Value>();
}
Local<Value> result;
if (!BootstrapNode().ToLocal(&result)) {
return MaybeLocal<Value>();
}
// Make sure that no request or handle is created during bootstrap -
// if necessary those should be done in pre-execution.
// Usually, doing so would trigger the checks present in the ReqWrap and
// HandleWrap classes, so this is only a consistency check.
CHECK(req_wrap_queue()->IsEmpty());
CHECK(handle_wrap_queue()->IsEmpty());
DoneBootstrapping();
return scope.Escape(result);
}
我們已經透過一個去#cronment 對象，這個Environment 實例已經有了一個模組系統NativeModule用來維護內建模組。 然後程式碼會運行到Run 函數的另一個重載版本：
function nativeModuleRequire(id) {
if (id === loaderId) {
return loaderExports;
}
const mod = NativeModule.map.get(id);
// Can't load the internal errors module from here, have to use a raw error.
// eslint-disable-next-line no-restricted-syntax
if (!mod) throw new TypeError(`Missing internal module '${id}'`);
return mod.compileForInternalLoader();
}
const loaderExports = {
internalBinding,
NativeModule,
require: nativeModuleRequire
};
return loaderExports;
在這裡呼叫[LoadEnvironment](https://github.com /nodejs/node/blob/881174e016d6c27b20c70111e6eae2296b6c6293/src/api/environment.cc#L403)：
：<pre class="brush:php;toolbar:false">MaybeLocal<Value> StartExecution(Environment* env, StartExecutionCallback cb) {
// 已省略其他运行方式，我们只看 `node index.js` 这种情况，不影响我们理解模块系统
if (!first_argv.empty() && first_argv != "-") {
return StartExecution(env, "internal/main/run_main_module");
}
}</pre>
<p>在 <code>StartExecution(env, "internal/main/run_main_module")这个调用中，我们会包装一个 function，并传入刚刚从 loaders 中导出的 require 函数，并运行 [lib/internal/main/run_main_module.js](https://github.com/nodejs/node/blob/881174e016d6c27b20c70111e6eae2296b6c6293/lib/internal/main/run_main_module.js) 内的代码：
'use strict';
const {
prepareMainThreadExecution
} = require('internal/bootstrap/pre_execution');
prepareMainThreadExecution(true);
markBootstrapComplete();
// Note: this loads the module through the ESM loader if the module is
// determined to be an ES module. This hangs from the CJS module loader
// because we currently allow monkey-patching of the module loaders
// in the preloaded scripts through require('module').
// runMain here might be monkey-patched by users in --require.
// XXX: the monkey-patchability here should probably be deprecated.
require('internal/modules/cjs/loader').Module.runMain(process.argv[1]);
所谓的包装 function 并传入 require，伪代码如下：
(function(require, /* 其他入参 */) {
// 这里是 internal/main/run_main_module.js 的文件内容
})();
所以这里是通过内置模块的 require 函数加载了 [lib/internal/modules/cjs/loader.js](https://github.com/nodejs/node/blob/881174e016d6c27b20c70111e6eae2296b6c6293/lib/internal/modules/cjs/loader.js#L172) 导出的 Module 对象上的 runMain 方法，不过我们在 loader.js 中并没有发现 runMain 函数，其实这个函数是在 [lib/internal/bootstrap/pre_execution.js](https://github.com/nodejs/node/blob/881174e016d6c27b20c70111e6eae2296b6c6293/lib/internal/bootstrap/pre_execution.js#L428) 中被定义到 Module 对象上的：
function initializeCJSLoader() {
const CJSLoader = require('internal/modules/cjs/loader');
if (!noGlobalSearchPaths) {
CJSLoader.Module._initPaths();
}
// TODO(joyeecheung): deprecate this in favor of a proper hook?
CJSLoader.Module.runMain =
require('internal/modules/run_main').executeUserEntryPoint;
}
在 [lib/internal/modules/run_main.js](https://github.com/nodejs/node/blob/881174e016d6c27b20c70111e6eae2296b6c6293/lib/internal/modules/run_main.js#L74) 中找到 executeUserEntryPoint 方法：
function executeUserEntryPoint(main = process.argv[1]) {
const resolvedMain = resolveMainPath(main);
const useESMLoader = shouldUseESMLoader(resolvedMain);
if (useESMLoader) {
runMainESM(resolvedMain || main);
} else {
// Module._load is the monkey-patchable CJS module loader.
Module._load(main, null, true);
}
}
参数 main 即为我们传入的入口文件 index.js。可以看到，index.js 作为一个 cjs 模块应该被 Module._load 加载，那么 _load干了些什么呢？这个函数是 cjs 模块加载过程中最重要的一个函数，值得仔细阅读：
// `_load` 函数检查请求文件的缓存
// 1. 如果模块已经存在，返回已缓存的 exports 对象
// 2. 如果模块是内置模块，通过调用 `NativeModule.prototype.compileForPublicLoader()`
// 获取内置模块的 exports 对象，compileForPublicLoader 函数是有白名单的，只能获取公开
// 内置模块的 exports。
// 3. 以上两者皆为否，创建新的 Module 对象并保存到缓存中，然后通过它加载文件并返回其 exports。
// request：请求的模块，比如 `fs`，`./another-module`，'@pipcook/core' 等
// parent：父模块，如在 `a.js` 中 `require('b.js')`，那么这里的 request 为 'b.js',
parent 为 `a.js` 对应的 Module 对象
// isMain: 除入口文件为 `true` 外，其他模块都为 `false`
Module._load = function(request, parent, isMain) {
let relResolveCacheIdentifier;
if (parent) {
debug('Module._load REQUEST %s parent: %s', request, parent.id);
// relativeResolveCache 是模块路径缓存，
// 用于加速父模块所在目录下的所有模块请求当前模块时
// 可以直接查询到实际路径，而不需要通过 _resolveFilename 查找文件
relResolveCacheIdentifier = `${parent.path}\x00${request}`;
const filename = relativeResolveCache[relResolveCacheIdentifier];
if (filename !== undefined) {
const cachedModule = Module._cache[filename];
if (cachedModule !== undefined) {
updateChildren(parent, cachedModule, true);
if (!cachedModule.loaded)
return getExportsForCircularRequire(cachedModule);
return cachedModule.exports;
}
delete relativeResolveCache[relResolveCacheIdentifier];
}
}
// 尝试查找模块文件路径，找不到模块抛出异常
const filename = Module._resolveFilename(request, parent, isMain);
// 如果是内置模块，从 `NativeModule` 加载
if (StringPrototypeStartsWith(filename, 'node:')) {
// Slice 'node:' prefix
const id = StringPrototypeSlice(filename, 5);
const module = loadNativeModule(id, request);
if (!module?.canBeRequiredByUsers) {
throw new ERR_UNKNOWN_BUILTIN_MODULE(filename);
}
return module.exports;
}
// 如果缓存中已存在，将当前模块 push 到父模块的 children 字段
const cachedModule = Module._cache[filename];
if (cachedModule !== undefined) {
updateChildren(parent, cachedModule, true);
// 处理循环引用
if (!cachedModule.loaded) {
const parseCachedModule = cjsParseCache.get(cachedModule);
if (!parseCachedModule || parseCachedModule.loaded)
return getExportsForCircularRequire(cachedModule);
parseCachedModule.loaded = true;
} else {
return cachedModule.exports;
}
}
// 尝试从内置模块加载
const mod = loadNativeModule(filename, request);
if (mod?.canBeRequiredByUsers) return mod.exports;
// Don't call updateChildren(), Module constructor already does.
const module = cachedModule || new Module(filename, parent);
if (isMain) {
process.mainModule = module;
module.id = '.';
}
// 将 module 对象加入缓存
Module._cache[filename] = module;
if (parent !== undefined) {
relativeResolveCache[relResolveCacheIdentifier] = filename;
}
// 尝试加载模块，如果加载失败则删除缓存中的 module 对象，
// 同时删除父模块的 children 内的 module 对象。
let threw = true;
try {
module.load(filename);
threw = false;
} finally {
if (threw) {
delete Module._cache[filename];
if (parent !== undefined) {
delete relativeResolveCache[relResolveCacheIdentifier];
const children = parent?.children;
if (ArrayIsArray(children)) {
const index = ArrayPrototypeIndexOf(children, module);
if (index !== -1) {
ArrayPrototypeSplice(children, index, 1);
}
}
}
} else if (module.exports &&
!isProxy(module.exports) &&
ObjectGetPrototypeOf(module.exports) ===
CircularRequirePrototypeWarningProxy) {
ObjectSetPrototypeOf(module.exports, ObjectPrototype);
}
}
// 返回 exports 对象
return module.exports;
};
module 对象上的 [load](https://github.com/nodejs/node/blob/881174e016d6c27b20c70111e6eae2296b6c6293/lib/internal/modules/cjs/loader.js#L963) 函数用于执行一个模块的加载：
Module.prototype.load = function(filename) {
debug('load %j for module %j', filename, this.id);
assert(!this.loaded);
this.filename = filename;
this.paths = Module._nodeModulePaths(path.dirname(filename));
const extension = findLongestRegisteredExtension(filename);
// allow .mjs to be overridden
if (StringPrototypeEndsWith(filename, '.mjs') && !Module._extensions['.mjs'])
throw new ERR_REQUIRE_ESM(filename, true);
Module._extensions[extension](this, filename);
this.loaded = true;
const esmLoader = asyncESM.esmLoader;
// Create module entry at load time to snapshot exports correctly
const exports = this.exports;
// Preemptively cache
if ((module?.module === undefined ||
module.module.getStatus() < kEvaluated) &&
!esmLoader.cjsCache.has(this))
esmLoader.cjsCache.set(this, exports);
};
实际的加载动作是在 Module._extensions[extension](this, filename); 中进行的，根据扩展名的不同，会有不同的加载策略：
-
.js：调用
fs.readFileSync读取文件内容，将文件内容包在 wrapper 中，需要注意的是，这里的require是Module.prototype.require而非内置模块的require方法。
const wrapper = [
'(function (exports, require, module, __filename, __dirname) { ',
'\n});',
];
而 Module.prototype.require 函数也是调用了静态方法 Module._load实现模块加载的：
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--;
}
};
总结
看到这里，cjs 模块的加载过程已经基本清晰了：
初始化 node，加载 NativeModule，用于加载所有的内置的 js 和 c++ 模块
运行内置模块
run_main在
run_main中引入用户模块系统module通过
module的_load方法加载入口文件，在加载时通过传入module.require和module.exports等让入口文件可以正常require其他依赖模块并递归让整个依赖树被完整加载。
在清楚了 cjs 模块加载的完整流程之后，我们还可以顺着这条链路阅读其他代码，比如 global 变量的初始化，esModule 的管理方式等，更深入地理解 node 内的各种实现。
更多node相关知识，请访问：nodejs 教程！
以上是探索 Node.js 原始碼，詳解cjs 模組的載入過程的詳細內容。更多資訊請關注PHP中文網其他相關文章！