深入理解 CommonJS 规范及 Node 模块实现

什么是 CommonJS 规范？

CommonJS 是 JavaScript 社区为了解决缺少适用于服务器端的 Module 标准而提出的一种模块化规范。其最初的定位是为了规范模块文件、模块导入、模块导出等相关概念。CommonJS 规范将所有的代码都认为是一个模块，每个模块有自己的作用域，可以定义变量，函数等，模块之间可以相互引用，但不能直接访问其他模块的变量，需要使用 require() 函数进行导入。

CommonJS 规范主要有哪些内容？

模块的定义

CommonJS 规范中，一个 JavaScript 文件就是一个独立的模块。在一个模块中，定义的任何变量、函数等都只在当前模块中有效。在模块中定义变量和函数的方式与普通的 JavaScript 定义方式相同。

模块中使用 module.exports 对象来导出模块内容，其他模块可以通过 require() 函数引入模块。

例如，以下是一个示例模块，导出了一个函数：

// export.js
function hello() {
  console.log('Hello, world!');
}
module.exports = hello;

require() 函数

require() 函数用于进行模块导入，在模块中使用 require() 函数导入其他模块。require() 函数接受一个参数，表示要导入的模块的路径。

例如，以下是一个使用 require() 函数导入模块的示例：

// main.js
const hello = require('./export');
hello();

上述示例代码中，main.js 主模块使用 require() 函数导入了 export.js 模块，并调用了其中导出的 hello() 函数。

模块加载机制

在 Node.js 中，模块的加载是同步的，即在当前模块中，对其他模块的 require() 调用是阻塞式执行的。使用 require() 加载模块时，Node.js 首先检查是否有缓存，如果有直接返回，否则按照一定顺序查找对应模块文件，然后加载并编译执行模块文件。因为模块加载是同步的，所以如果模块之间有互相依赖的关系，需要注意循环依赖问题。

Node 模块化实现

在 Node.js 中，采用了和 CommonJS 规范一致的模块化实现方式。Node.js 的模块化主要有两种类型：核心模块和文件模块。

核心模块

核心模块是 Node.js 中自带的模块，如 http、fs、path 等。Node.js 在启动时会将核心模块加载到内存中，以便于提高运行效率。

要使用核心模块，只需要通过 require() 函数导入即可，如：

const http = require('http');

文件模块

除了核心模块，Node.js 其他所有的模块都是文件模块。文件模块是根据文件系统进行加载的，指定的路径可以是相对路径或绝对路径。使用 require() 函数加载文件模块时，需要指定文件的相对路径或绝对路径。文件模块采用同步方式进行加载，加载后会被放入缓存。

例如，以下是一个读取文件的示例：

// file.js
const fs = require('fs');
const content = fs.readFileSync('./example.txt');
console.log(content.toString());

上述示例代码中，fs 模块是 Node.js 中的核心模块，通过 require() 函数导入。readFileSync() 函数是 Node.js 提供的一个用于读取文件内容的函数，返回的是一个 Buffer 类型的数据，需要使用 toString() 方法将其转换为字符串。

示例

例如，以下是一个模块之间相互依赖的示例：

// a.js
const b = require('./b');
console.log('a.js loaded');
exports.done = false;
console.log('a.js execute b.doSomething():', b.doSomething());
console.log('a.js set done:', true);
exports.done = true;
console.log('a.js exports:', exports);

// b.js
const a = require('./a');
console.log('b.js loaded');
exports.done = false;
function doSomething() {
  console.log('doSomething in b.js');
  return 'something';
}
exports.doSomething = doSomething;
console.log('a.done:', a.done);
console.log('b.js exports:', exports);

上述代码中，a.js 通过 require 函数加载了 b.js 模块，而 b.js 中又通过 require 函数加载了 a.js 模块。这两个模块之间存在循环依赖关系。

执行 node a.js 命令时的控制台输出结果为：

b.js loaded
a.done: false
b.js exports: { done: false, doSomething: [Function: doSomething] }
a.js loaded
a.js execute b.doSomething(): something
a.js set done: true
a.js exports: { done: true }

另一个示例是：

// math.js
module.exports = {
  add: (a, b) => {
    return a + b;
  },
  sub: (a, b) => {
    return a - b;
  }
};

// main.js
const { add, sub } = require('./math');
console.log('1 + 2 =', add(1, 2));
console.log('2 - 1 =', sub(2, 1));

上述代码中，math.js 将两个函数封装在了一个对象中，并导出该对象。main.js 使用对象的解构语法从模块中导入了 add 和 sub 两个函数，并使用它们执行计算。

执行 node main.js 命令时的控制台输出结果为：

1 + 2 = 3
2 - 1 = 1

以上两个示例分别演示了模块之间相互依赖以及模块的导出和导入。