CommonJS模块系统

CommonJS模块系统是Node.js中用于组织和管理代码的核心机制之一。它通过require和module.exports实现模块的导入和导出，解决了早期JavaScript缺乏原生模块化支持的问题。

CommonJS模块系统的基本概念

CommonJS规范最初是为服务器端JavaScript环境设计的，Node.js采用了这一规范作为其模块系统的基础。每个文件被视为一个独立的模块，具有自己的作用域，模块内部的变量、函数和类默认对外不可见。

模块系统的主要特点包括：

• 同步加载模块
• 模块只加载一次并缓存
• 模块路径解析规则明确
• 支持循环依赖处理

模块导出机制

CommonJS提供了两种主要的导出方式：

module.exports导出

这是最基础的导出方式，允许将整个对象赋值给模块的导出：

// math.js
function add(a, b) {
  return a + b
}

module.exports = {
  add: add,
  PI: 3.1415926
}

exports快捷方式

exports是module.exports的一个引用，可以简化导出操作：

// utils.js
exports.upperCase = function(str) {
  return str.toUpperCase()
}

exports.lowerCase = function(str) {
  return str.toLowerCase()
}

注意：不能直接对exports重新赋值，这会切断它与module.exports的关联：

// 错误示例
exports = function() {} // 这将导致导出失效

模块导入机制

使用require函数导入模块是CommonJS的核心特性：

const math = require('./math.js')
const { upperCase } = require('./utils')

console.log(math.add(2, 3)) // 5
console.log(upperCase('hello')) // HELLO

require函数支持多种路径形式：

• 相对路径（./或../开头）
• 绝对路径
• 核心模块名称（如fs、path）
• 第三方模块名称（从node_modules加载）

模块缓存机制

Node.js会对加载过的模块进行缓存，后续的require调用会直接返回缓存结果：

// moduleA.js
console.log('模块A被加载')
module.exports = { value: 42 }

// main.js
require('./moduleA') // 打印"模块A被加载"
require('./moduleA') // 无输出，直接返回缓存

缓存可以通过require.cache访问，也可以删除特定缓存：

delete require.cache[require.resolve('./moduleA')]

模块加载顺序

Node.js按照以下顺序解析模块路径：

1. 检查是否是核心模块
2. 检查是否以./、../或/开头
3. 从当前目录的node_modules查找
4. 向上级目录的node_modules查找，直到根目录
5. 查找全局安装的模块

循环依赖处理

CommonJS可以处理模块间的循环依赖，但需要注意导出值的时机：

// a.js
console.log('a开始加载')
exports.done = false
const b = require('./b.js')
console.log('在a中，b.done =', b.done)
exports.done = true
console.log('a加载完成')

// b.js
console.log('b开始加载')
exports.done = false
const a = require('./a.js')
console.log('在b中，a.done =', a.done)
exports.done = true
console.log('b加载完成')

// main.js
console.log('main开始加载')
const a = require('./a.js')
const b = require('./b.js')
console.log('在main中，a.done=', a.done, 'b.done=', b.done)

执行结果会展示模块加载的顺序和状态变化。

模块包装器

Node.js在执行模块代码前会将其包装在一个函数中：

(function(exports, require, module, __filename, __dirname) {
  // 模块代码实际在这里
})

这解释了为什么模块中有这些变量可用：

• __filename：当前模块文件的绝对路径
• __dirname：当前模块所在目录的绝对路径

动态加载与条件加载

由于require是普通函数，可以实现动态加载：

// 根据环境加载不同配置
const config = process.env.NODE_ENV === 'production'
  ? require('./config.prod')
  : require('./config.dev')

也可以实现按需加载：

// 延迟加载大型模块
function getImageProcessor() {
  const sharp = require('sharp')
  return sharp
}

模块系统与ES模块的差异

虽然Node.js现在支持ES模块，但CommonJS仍有重要区别：

1. CommonJS是同步加载，ES模块是异步加载
2. CommonJS模块是动态的，ES模块是静态的
3. CommonJS中require可任意位置调用，ES模块import必须顶层
4. CommonJS模块值是拷贝，ES模块是实时绑定

实际应用中的最佳实践

1. 组织大型项目结构：

project/
  ├── lib/
  │   ├── utils/
  │   │   ├── string.js
  │   │   └── array.js
  │   └── services/
  │       ├── api.js
  │       └── db.js
  ├── config/
  │   ├── default.js
  │   └── production.js
  └── app.js

2. 创建索引文件简化导入：

// lib/utils/index.js
module.exports = {
  ...require('./string'),
  ...require('./array')
}

// 使用处
const { upperCase, chunk } = require('./lib/utils')

3. 处理配置覆盖：

// config.js
const defaults = require('./defaults')
const overrides = require('./overrides')

module.exports = { ...defaults, ...overrides }

调试模块系统

可以通过module对象访问模块信息：

console.log(module)

或者使用Node.js的--inspect参数配合Chrome DevTools调试模块加载过程。

性能考量

1. 避免过度嵌套的require调用
2. 对于频繁使用的模块，考虑在应用启动时加载
3. 大型模块可以拆分为子模块延迟加载
4. 监控require.cache大小防止内存泄漏

模块系统的扩展应用

1. 实现插件系统：

// 加载plugins目录下所有.js文件
const fs = require('fs')
const path = require('path')

const plugins = {}
const pluginDir = path.join(__dirname, 'plugins')

fs.readdirSync(pluginDir)
  .filter(file => file.endsWith('.js'))
  .forEach(file => {
    const plugin = require(path.join(pluginDir, file))
    plugins[plugin.name] = plugin
  })

2. 实现中间件模式：

// middleware.js
const middlewares = []

function use(middleware) {
  middlewares.push(middleware)
}

function run(context) {
  let index = 0
  function next() {
    if (index < middlewares.length) {
      middlewares[index++](context, next)
    }
  }
  next()
}

module.exports = { use, run }

模块系统的底层实现

Node.js的模块系统底层主要依赖：

1. Module类：每个模块都是其实例
2. Module._load：核心加载逻辑
3. Module._resolveFilename：路径解析
4. Module._compile：代码编译执行

可以通过修改Module.prototype扩展模块行为（谨慎使用）：

const originalRequire = Module.prototype.require

Module.prototype.require = function(id) {
  console.log(`Requiring: ${id}`)
  return originalRequire.call(this, id)
}

常见问题与解决方案

1. 模块未找到错误：

   • 检查路径是否正确
   • 确认模块是否安装
   • 检查NODE_PATH环境变量

2. 循环依赖导致未完成导出：

   • 重构代码消除循环依赖
   • 将依赖延迟到函数内部

3. 缓存导致无法获取最新代码：

   • 开发时使用nodemon等工具
   • 手动清除缓存

4. 模块作用域污染：

   • 确保不声明全局变量
   • 使用严格模式

模块系统与打包工具

虽然CommonJS是Node.js原生支持，但前端工具如Webpack、Browserify可以将其打包用于浏览器：

// webpack.config.js
module.exports = {
  entry: './src/index.js',
  output: {
    filename: 'bundle.js',
    path: path.resolve(__dirname, 'dist')
  }
}

这些工具会解析require调用，将所有依赖打包为单个文件。

模块系统的未来演进

随着ES模块成为JavaScript标准，Node.js也在逐步增强ES模块支持。但在可预见的未来，CommonJS仍将是Node.js生态的重要组成部分，特别是在：

• 已有的大型代码库
• 需要动态加载的场景
• 与大量现有npm包的兼容性

理解CommonJS模块系统的工作原理和特性，对于Node.js开发者来说仍然是必备的基础知识。