CommonJS 模块加载机制详解：深入理解 Require 函数的递归与缓存

本文深入剖析 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 的代码。

   

   企奶奶

   一款专注于企业信息查询的智能大模型，企奶奶查企业，像聊天一样简单。

   下载

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 模块加载机制。