本文深入剖析 CommonJS 模块加载机制，重点讲解 require 函数的工作原理，包括模块缓存、函数包装以及递归加载过程。通过示例代码，详细解释了 require 如何避免重复加载模块、如何处理模块间的依赖关系，以及 wrapper 函数在模块加载过程中的作用。帮助读者彻底理解 CommonJS 模块加载的内部机制。

CommonJS 规范定义了 JavaScript 在服务器端的模块化方案，其核心在于 require 函数。require 函数负责加载模块，并处理模块间的依赖关系。为了提高效率，CommonJS 使用缓存机制，避免重复加载相同的模块。下面我们将深入探讨 require 函数的实现原理，并结合示例代码进行详细说明。

require 函数的基本结构

一个简化的 require 函数实现如下：

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 是一个对象，用于存储已经加载过的模块。键是模块名，值是模块对象。
2. 检查缓存： require 函数首先检查模块是否已经加载过。如果存在于 require.cache 中，则直接返回缓存的模块的 exports 属性。
3. 加载模块： 如果模块未加载，则读取模块代码，创建一个新的模块对象，并将其添加到 require.cache 中。
4. 函数包装： 使用 Function 构造函数创建一个包装函数 wrapper。该函数接受 require、exports 和 module 作为参数，并将模块代码包裹在其中。
5. 执行包装函数： 调用 wrapper 函数，传入 require 函数自身、module.exports 对象以及 module 对象。
6. 返回模块： 返回 require.cache[name].exports，即模块导出的内容。

递归加载与函数包装

require 函数的一个关键特性是能够递归地加载模块。这意味着一个模块可以依赖于其他模块，而 require 函数能够处理这种依赖关系。

考虑以下三个模块：

• square.js:

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

• squareAll.js:

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

• index.js:

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

当执行 require(‘./squareAll’) 时，require 函数会执行以下步骤：

1. 读取 squareAll.js 的代码。

   

   文心大模型

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

   56

   查看详情

2. 创建一个 wrapper 函数，该函数类似于：

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

3. 调用 wrapper 函数，传入 require、module.exports 和 module。

4. 在 wrapper 函数内部，执行 const square = require(‘./square’)。这将递归地调用 require 函数来加载 square.js 模块。

5. require(‘./square’) 执行类似的过程，读取 square.js 的代码，创建 wrapper 函数，执行 wrapper 函数，并将 square 函数赋值给 module.exports。

6. require(‘./square’) 返回 square 函数。

7. 回到 squareAll.js 的 wrapper 函数，将 square 函数赋值给 square 变量，并定义 squareAll 函数。

8. 将 squareAll 函数赋值给 module.exports。

9. require(‘./squareAll’) 返回 squareAll 函数。

注意事项与总结

• 模块路径： require 函数使用模块名作为参数。模块名可以是相对路径或绝对路径。相对路径是相对于当前模块的路径。
• 循环依赖： CommonJS 允许循环依赖，但需要小心处理。如果模块 A 依赖于模块 B，而模块 B 又依赖于模块 A，可能会导致一些问题。
• 缓存机制： require.cache 显著提升了模块加载的性能，避免了重复加载相同的模块。

总而言之，CommonJS 的 require 函数通过缓存机制、函数包装和递归加载，实现了高效且灵活的模块化方案。理解 require 函数的工作原理对于编写高质量的 Node.js 代码至关重要。 通过本文的详细解析，希望能帮助读者更深入地理解 CommonJS 模块加载机制。