一、初识模块:从一个小盒子说起

写Node.js的时候,我们天天都在用require或import。你有没有想过,为啥有的代码写个require就能用,有的却要import?这背后其实就是Node.js的模块加载机制。

打个比方,你的代码就像一个大房子,每个模块就是里面的小房间。require就像你去敲邻居家的门,借个工具用用。Node.js需要知道怎么找到那个邻居,怎么把工具借给你,还不用担心邻居把工具弄丢了。

1.1 什么是模块

模块就是一段可以复用的代码。你把一些功能封装在一个文件里,这个文件就是一个模块。模块可以导出自己的东西,也可以引入别人的东西。

举个例子,你有一个数学工具模块:

// utils.js
// 这是一个简单的工具模块
const PI = 3.14159;

// 导出一个计算圆面积的方法
function circleArea(r) {
  // 半径的平方乘以圆周率
  return PI * r * r;
}

// 把这个方法暴露出去,其他文件才能用
module.exports = {
  circleArea,
  PI
};

另一个文件要用这个工具:

// main.js
// 引入上面写的工具模块
const utils = require('./utils');

// 使用里面的方法计算面积
const area = utils.circleArea(5);
console.log('半径是5的圆面积是:', area);

你看,就这么简单。require把utils.js里的东西拿过来了。但是,这里头有个问题——Node.js是怎么找到utils.js这个文件的?它怎么知道这个文件在哪?

1.2 路径解析:找邻居家的门牌号

Node.js找模块有一套自己的规则。当你写require('./utils')时,它会做这么几件事:

  • 先看路径,如果以./或../开头,就按相对路径找
  • 如果是以/开头,就按绝对路径找
  • 如果没有这些前缀,就去node_modules里找

这个查找过程有个很有意思的细节:如果路径是./utils,Node.js会先找utils.js文件,找不到就找utils.json,再找不到就找utils.node,都找不到就会尝试把utils当目录,找utils/index.js等。

看这个示例:

// 假设项目结构是这样的:
// project/
//   src/
//     main.js
//     helper.js
//   node_modules/
//     some-package/
//       index.js

// 在main.js中:
const helper = require('./helper');      // 找src/helper.js
const config = require('../config');      // 找project/config.js
const somePkg = require('some-package');  // 找node_modules/some-package/index.js

注意看,require('./helper')和require('some-package')的区别。前者是相对路径,后者是包名。Node.js会根据这个来区分去哪里找。

二、两种加载方式:CommonJS与ES模块

Node.js发展到现在,有两种模块系统:CommonJS和ES模块。它们就像两种不同的语言,各有各的规矩。

2.1 CommonJS:老规矩

CommonJS是Node.js一开始就有的模块系统。它用require加载,用module.exports导出。它是同步的,也就是说,加载完一个模块才能继续执行下一行代码。

// math-tool.js
// 定义一个加法函数
function add(a, b) {
  // 返回两个数相加的结果
  return a + b;
}

// 导出这个函数
module.exports = add;

使用它:

// app.js
// 引入上面的加法函数
const add = require('./math-tool');

// 直接调用
console.log(add(2, 3)); // 输出 5

CommonJS的特点是简单直接,但它是同步的,在浏览器里用不了(因为浏览器没有文件系统)。

2.2 ES模块:新规矩

ES模块是JavaScript标准里的模块系统。它用import和export关键字。它是异步的,而且在语法上更清晰。

// es-math.mjs
// 导出两个函数
export function add(a, b) {
  // 加法
  return a + b;
}

export function subtract(a, b) {
  // 减法
  return a - b;
}

使用它:

// es-app.mjs
// 引入上面的函数
import { add, subtract } from './es-math.mjs';

// 使用
console.log(add(10, 5));      // 输出 15
console.log(subtract(10, 5)); // 输出 5

看到区别了吗?import必须放在文件顶部(其实也可以动态导入),而require可以放在任何地方。而且import是静态的,也就是说,模块关系在代码运行前就确定了,这有利于Tree-Shaking等优化。

2.3 怎么选?

在Node.js里,.js文件默认是CommonJS,.mjs文件是ES模块。你也可以在package.json里设置"type": "module"让.js文件也按ES模块处理。

{
  "type": "module"
}

这个配置会告诉Node.js:这个项目里的.js文件都用ES模块语法。

不过要注意,混用两种模块系统会报错。比如在CommonJS里不能直接import,在ES模块里也不能直接require。但Node.js提供了一些办法,比如createRequire。

// 在ES模块中想用require
import { createRequire } from 'module';
const require = createRequire(import.meta.url);

// 现在可以用了
const utils = require('./utils');

这个技巧有时候很有用,特别是迁移老项目的时候。

三、模块缓存:为什么加载两次只执行一次

这是Node.js模块系统最容易被忽视但很重要的机制。当你require同一个模块两次,第二次不会再执行模块代码了,而是直接返回第一次缓存的结果。

3.1 缓存是怎么工作的

Node.js有一个全局缓存对象require.cache。当你加载一个模块时,Node.js会把这个模块的路径作为key,模块对象作为value存起来。

来看这个例子:

// counter.js
// 一个计数器模块
let count = 0;

function increment() {
  // 每次调用加一
  count++;
  return count;
}

module.exports = { increment };
// main.js
// 引入两次同一个模块
const counter1 = require('./counter');
const counter2 = require('./counter');

// 调用increment
counter1.increment(); // count变成1
counter2.increment(); // count变成2,而不是1

console.log(counter1.increment()); // 输出3,不是2
console.log(counter2 === counter1); // true,是同一个对象

看到没?counter1和counter2指向同一个对象。因为第一次require时,Node.js执行了counter.js,把结果存进了缓存。第二次require时,发现缓存里有,直接返回,不执行代码。

3.2 为什么要有缓存

缓存有好处也有坏处。好处是性能好,不会重复执行模块代码,特别是有大量计算或网络请求的模块。坏处是,如果你修改了模块代码,但缓存里还是旧版本,需要重启进程才能生效。

这个特点在开发时可能带来困惑。比如你改了counter.js,但main.js里还是用旧的结果。解决办法是重启Node.js进程,或者手动清除缓存:

// 手动清除某个模块的缓存
delete require.cache[require.resolve('./counter')];

// 或者清除所有缓存
Object.keys(require.cache).forEach(key => {
  delete require.cache[key];
});

不过生产环境不建议这么做,因为缓存是性能优化的重要部分。

3.3 循环依赖:模块之间的死循环

这是一个经典问题。模块A引用模块B,模块B又引用模块A。这时候Node.js怎么处理?

// a.js
// 模块A引用模块B
const b = require('./b');
console.log('a.js执行完毕');

module.exports = { name: 'A' };
// b.js
// 模块B引用模块A
const a = require('./a');
console.log('b.js执行完毕');

module.exports = { name: 'B' };
// main.js
// 入口文件
require('./a');

运行main.js会发生什么?首先执行a.js,遇到require('./b'),然后执行b.js。在b.js里遇到require('./a'),但a.js还在执行中,还没有导出任何东西,所以a是空对象{}。然后b.js继续执行完,返回给a.js。a.js继续执行完。

输出结果会是:

b.js执行完毕
a.js执行完毕

所以,循环依赖不会死循环,但可能拿到不完整的结果。如果b.js试图用a.name,就会得到undefined。

解决办法是设计好模块之间的依赖关系,尽量不要循环依赖。如果不可避免,可以用延迟访问:

// a.js
const b = require('./b');

// 不直接访问b,而是通过函数访问
module.exports = {
  getName() {
    return 'A';
  },
  useB() {
    // 延迟到调用时才访问b
    return b.name;
  }
};

这样useB方法被调用时,b已经加载完成了。

四、生产环境下的模块加载优化

开发时我们关心能不能跑起来,生产环境更关心性能和稳定性。加载优化主要解决几个问题:启动时间、内存占用、模块体积。

4.1 使用构建工具打包

最常见也最有效的方法是用构建工具,比如Webpack、Rollup、esbuild等。它们会把所有模块打包成一个或几个文件,减少文件IO次数。

# 使用esbuild打包
npx esbuild app.js --bundle --minify --outfile=dist/app.js

这个命令会把app.js及其依赖打包成一个dist/app.js文件,并压缩。这样Node.js只需要加载一个文件,而不是成百上千个。

4.2 动态导入:按需加载

如果你的应用很大,有些模块只在特定场景下才用,可以用动态导入。这样可以减少启动时的加载量。

// app.js
// 动态导入一个模块,只有点击按钮时才加载
document.getElementById('btn').addEventListener('click', async () => {
  // 点击按钮时才加载这个模块
  const { showDialog } = await import('./dialog.js');
  showDialog();
});

在Node.js里也可以用:

// server.js
// 根据请求动态加载不同的处理逻辑
app.get('/api/user', async (req, res) => {
  // 路由处理时才加载对应模块
  const handler = await import('./handlers/user.js');
  handler.default(req, res);
});

动态导入的好处是,不需要的代码不会在启动时执行。坏处是,第一次访问时会有额外的等待时间。但总比启动时全部加载要好。

4.3 减少模块查找路径

Node.js查找模块时,会逐级向上找node_modules。如果模块很多,这个过程可能变慢。

// 设置NODE_PATH环境变量
// 在package.json的scripts中:
{
  "scripts": {
    "start": "NODE_PATH=./src/node_modules node app.js"
  }
}

这样可以减少查找层级,但需要注意,NODE_PATH是全局变量,容易造成混淆。更好的办法是把常用模块放在项目的node_modules里。

4.4 使用生产模式

Node.js有NODE_ENV环境变量。在开发和生产模式下,模块加载行为可能不同。

# 设置生产环境
NODE_ENV=production node app.js

很多库(比如React、Express)会根据这个变量决定是否执行开发模式特有的检查或日志。

4.5 使用Worker线程

如果你有CPU密集型的模块加载,可以考虑用Worker线程。Worker可以并行执行任务,不阻塞主线程。

// worker.js
// 一个Worker线程执行模块加载
const { parentPort } = require('worker_threads');

// 加载一个耗时的模块
const heavyModule = require('./heavy-module.js');

// 发送结果给主线程
parentPort.postMessage(heavyModule.process());
// main.js
// 主线程
const { Worker } = require('worker_threads');

// 创建一个Worker
const worker = new Worker('./worker.js');

// 接收结果
worker.on('message', result => {
  console.log('Worker返回结果:', result);
});

4.6 利用缓存策略

生产环境中,模块加载后不会轻易变化。可以利用Node.js的模块缓存特性,避免重复加载。

但要注意,如果模块代码有变化,缓存不会自动失效。这时候需要重启进程或使用热更新(如nodemon、pm2等工具)。

# 使用nodemon自动重启
npx nodemon app.js

五、应用场景与注意事项

5.1 应用场景

模块加载机制在很多地方都能体现价值:

  • 大型Web应用:通过构建工具打包,减少启动时间
  • 微服务架构:每个服务可以独立加载所需模块
  • CLI工具:按需加载命令模块,加快启动速度
  • 插件系统:动态加载插件,实现扩展功能

5.2 技术优缺点

CommonJS的优点:

  • 简单直观,同步加载,代码结构清晰
  • 在Node.js中完全支持,无需额外配置
  • 大量老牌库都使用CommonJS

CommonJS的缺点:

  • 不能静态分析,不利于Tree-Shaking
  • 在浏览器中不能直接使用

ES模块的优点:

  • 静态分析,有利于Tree-Shaking
  • 原生支持,浏览器和Node.js都兼容
  • 语法更简洁

ES模块的缺点:

  • 需要Node.js 14+版本
  • 异步加载在某些场景下可能造成延迟
  • 与旧代码兼容性差

5.3 注意事项

  1. 不要随意修改require.cache:这可能导致难以调试的问题
  2. 避免循环依赖:设计时就要考虑模块依赖关系
  3. 路径大小写敏感:Windows和Linux上文件系统不同,./Utils和./utils可能不一样
  4. 使用绝对路径导入:在大型项目中,相对路径容易混乱,建议用__dirname或import.meta.url拼接
  5. 控制模块体积:一个模块太大会影响加载速度,建议按功能拆分

六、总结

Node.js的模块加载机制看起来简单,实际有很多细节值得深入理解。从require的路径解析,到模块缓存,再到循环依赖的处理,每一个环节都关系到应用的性能和稳定性。

在生产环境,通过构建工具、动态导入、合理配置NODE_ENV等方式,可以有效优化加载性能。但要记住,优化不是目的,代码的可维护性和可读性才是根本。过度优化可能带来复杂的配置和难以调试的问题。

理解这些机制后,你会发现,原来require和import不只是两行代码,它们背后是Node.js精心设计的模块系统,理解它能让你的Node.js开发之路走得更顺畅。