本文旨在深入剖析 CommonJS 模块系统中 `require` 函数的工作原理，特别是其递归调用和模块缓存机制。通过具体示例，我们将详细解释 `require` 如何加载、封装和缓存模块，以及递归调用在模块依赖关系中的作用。理解这些机制对于编写高质量的 Node.js 代码至关重要。 ### CommonJS 模块加载机制 在 CommonJS 模块系统中，`require` 函数是模块加载的核心。它负责查找、加载、执行并缓存模块。以下是一个简化的 `require` 函数实现： “`javascript require.cache = Object.create(null); function require(name) { if (!(name in require.cache)) { let code = readFile(name); // 读取模块代码 let module = {exports: {}}; // 创建模块对象 require.cache[name] = module; // 缓存模块对象 let wrapper = Function(“require, exports, module”, code); // 创建封装函数 wrapper(require, module.exports, module); // 执行封装函数 } return require.cache[name].exports; // 返回模块导出 }

这个实现展示了 require 的基本流程：

1. 检查缓存： 首先检查模块是否已加载到缓存 require.cache 中。如果存在，则直接返回缓存的 exports 对象。
2. 读取模块代码： 如果模块未加载，则使用 readFile(name) 函数读取模块的源代码。readFile 函数的具体实现取决于运行环境（Node.js 或浏览器）。
3. 创建模块对象： 创建一个新的模块对象 module，其中 module.exports 是模块导出的对象。
4. 缓存模块对象： 将模块对象添加到缓存 require.cache 中，以便后续使用。
5. 创建封装函数： 使用 Function 构造函数创建一个封装函数 wrapper。这个函数接收 require、exports 和 module 作为参数，并将模块的源代码作为函数体。
6. 执行封装函数： 调用 wrapper 函数，并将 require、module.exports 和 module 作为参数传递给它。这使得模块代码可以访问 require 函数，并修改 module.exports 对象。
7. 返回模块导出： 返回 require.cache[name].exports，即模块导出的对象。

递归调用

require 函数的递归调用是 CommonJS 模块系统的一个关键特性。当一个模块依赖于其他模块时，它会使用 require 函数加载这些依赖模块。这会导致 require 函数被递归调用，直到所有依赖模块都被加载和执行。

为了更好地理解递归调用，我们考虑以下示例：

square.js:

// square.js const square = function (n) {   return n * n; }  module.exports = square;

squareAll.js:

// squareAll.js const square = require('./square');  const squareAll = function (ns) {   return ns.map(n => square(n)); }  module.exports = squareAll;

index.js:

// index.js const squareAll = require('./squareAll');  console.log(squareAll([1, 2, 3, 4, 5]));

当 index.js 首次调用 require(‘./squareAll’) 时，require 函数会执行以下步骤：

1. 检查 squareAll.js 是否已加载到缓存中。由于这是首次加载，因此缓存中不存在。
2. 读取 squareAll.js 的代码。
3. 创建一个新的模块对象 module。
4. 将模块对象添加到缓存中。
5. 创建一个封装函数 wrapper，其函数体是 squareAll.js 的代码。
6. 调用 wrapper 函数。在 wrapper 函数内部，会调用 require(‘./square’)。

此时，require 函数被递归调用，以加载 square.js。require 函数会重复上述步骤，加载、封装和执行 square.js。一旦 square.js 加载完成，require 函数会返回 square 函数，并将其赋值给 squareAll.js 中的 square 变量。

文心大模型

百度飞桨-文心大模型 ERNIE 3.0 文本理解与创作

56

查看详情

然后，squareAll.js 继续执行，定义 squareAll 函数，并将其导出。最后，require 函数返回 squareAll 函数，并将其赋值给 index.js 中的 squareAll 变量。

模块缓存

CommonJS 模块系统使用缓存来避免重复加载模块。当一个模块被 require 函数加载后，它会被添加到缓存 require.cache 中。后续对同一模块的 require 调用会直接从缓存中返回模块的导出，而无需重新加载和执行模块代码。

模块缓存机制可以显著提高模块加载的效率，并避免潜在的副作用，例如多次执行初始化代码。

在上面的例子中，如果 squareAll.js 中多次 require(‘./square’)，那么 square.js 只会被加载和执行一次。后续的 require(‘./square’) 调用会直接从缓存中返回 square 函数。

注意事项与总结

• 循环依赖： CommonJS 允许循环依赖，但需要谨慎处理。如果两个或多个模块相互依赖，可能会导致一些问题，例如未完全初始化的模块。
• 模块作用域： CommonJS 模块具有独立的作用域。在一个模块中定义的变量和函数不会泄漏到其他模块。
• module.exports vs. exports： module.exports 是真正的导出对象。exports 只是 module.exports 的一个引用。如果直接给 exports 赋值，会断开与 module.exports 的连接，导致导出失败。

理解 CommonJS 模块系统的 require 机制对于编写可维护、可扩展的 Node.js 应用程序至关重要。 掌握递归调用和模块缓存的原理，可以帮助你更好地组织代码，避免潜在的问题，并提高应用程序的性能。