最近在看Node的书籍中，经常提到CommonJS规范，在问了度娘后顺手做个摘要。

CommonJS是Node使用的模块化标准，在CommonJS规范中，一个文件就是一个模块，模块具有单独的作用域，在模块内定义的变量、函数、类等都是私有的，对其他文件不可见。

CommonJS目前分为1.0和1.1两个版本，1.1版本主要在模块上下文(Module Context)部分增加了一些规范，这里就聊一下新的1.1版本吧。

模块上下文

  • 在一个模块中存在一个自由变量“require”函数，这个“rquire”函数接收一个模块标识符，返回外部模块所输出的API。
  • 如果出现依赖闭环(dependency cycle)，那么外部模块在被它的传递依赖(transitive dependencies)所require的时候可能并没有执行完成，这种情况下“require“返回的对象必须至少包含此外部模块在调用require函数之前就已经准备完毕的输出。
  • 如果请求模块不能返回，那么”require“必须抛出一个错误。
  • require有一个只读的、不可删除的”main“属性。”main“相当于程序根目录的module。如果设置了该属性，则其必须和根目录的module指向相同的对象。
  • require有个paths属性，该属性是一个具有优先秩序的路径数组，优先级从高到低，路径一直回朔到地根模块目录。

1.paths属性不会存在于沙盒中。
2.在所有模块中paths的attribute均指向相同的值。
3.paths是无法被替换的。
4.当paths的attribute存在时，修改paths的内容可能会导致模块无法被正确的搜索到。
5.当paths的attribute存在时，它可能只包含了部分path,当模块加载器在使用这些路径之前或者之后，去检查其它的路径。
6.当paths的attribute存在时,它是模块加载器使paths规范化、标准化的依据

exports

在一个模块中，存在一个名为”exports“的自由变量，它是一个对象，模块可以在执行的时候把自身API加入到其中。
模块必须将exports作为导出对象的唯一工具。
模块必须使用”exports“对象来作为输出的唯一表示。
module对象有一个制度的、不可删除的id属性。当执行require(module.id)时，可以通过该id找到对应的module并返回module exports出的对象。
当创建一个module对象时，该对象可以有一个URI属性。该属性指向对应的模块源文件。该URI不存在于沙盒中。

exports定义模块

在CommonJS中使用exports定义模块。

1
2
3
4
5
6
7
8
const testVal = 100;

function test() {
    console.log(testVal);
}

module.exports.testVal = testVal;
module.exports.testFn = test;

module对象

其中，module对象代表当前模块（Node内部提供了一个Module构造函数，所有模块都是Module实例）。module对象中包括：
children：Array，表示该模块要用到的其他模块，数组元素为其他模块的module对象
exports：Object，表示模块对外暴露的内容
filename：String，表示带绝对路径的文件名
id：String，表示文件的标识符， 通常是带有绝对路径的模块文件名
loaded：Boolean，返回一个布尔值，表示模块是否已经完成加载
parent：Object，表示调用该模块的模块
paths：Array，表示该模块的目录数组

exports对象

为了方便使用，Node提供了一个exports变量，指向module.exports。因此在定义输出接口时，可以向exports对象添加方法。

1
2
3
4
5
6
7
8
exports.dosth = function() { ... }

// 等同于
module.exports.dosth = function() { ... }

// 另一种写法
function dosth() { ... }
module.exports.dosth = dosth;

在使用exports时必须要注意一点！！！就是不能修改exports的指向。

1
2
3
4
5
6
7
8
// 以下定义方式改变了exports的指向，exports对象会被当做普通的函数/对象
// 外部无法通过require获取

exports = function() { ... }

exports = {
  xx: 1
}

建议统一使用module.exports。

定义模块的几种方式

####命名导出
暴露API的最基本方法，将所有要公开的值作为属性赋给exports对象。
exports.xxx = () => { ... }

导出函数

将整个module.exports变量重新分配给一个函数，主要优点是只暴露一个单一的功能，这为模块提供了一个明确的入口点，使其更容易理解和使用。
module.exports = () => { ... };

导出构造函数

导出构造函数的模块是导出函数的模块的特例。其不同之处在于，使用这种新模式，我们允许用户使用构造函数创建新的实例，但是我们也可以扩展其原型并创建新类（继承）。以下是此模式的示例：

1
2
3
4
5
6
7
8
// file logger.js
function Logger(name) {
  this.name = name;
}
Logger.prototype.log = function(message) {
  console.log(`[${this.name}] ${message}`);
};
module.exports = Logger;

我们通过以下方式使用上述模块：

1
2
3
4
// file main.js
const Logger = require('./logger');
const dbLogger = new Logger('DB');
dbLogger.log('...');

我们还可以使用ES6提供的class类实现上述代码。

导出实例

我们可以利用require()的缓存机制来轻松地定义具有从构造函数或工厂创建的状态的有状态实例，可以在不同模块之间共享。以下代码显示了此模式的示例：

1
2
3
4
5
6
7
8
9
10
//file logger.js
function Logger(name) {
  this.count = 0;
  this.name = name;
}
Logger.prototype.log = function(message) {
  this.count++;
  console.log('[' + this.name + '] ' + message);
};
module.exports = new Logger('DEFAULT');

这个新定义的模块可以这么使用：

1
2
3
// file main.js
const logger = require('./logger');
logger.log('This is an informational message');

因为模块被缓存，所以每个需要Logger模块的模块实际上总是会检索该对象的相同实例，从而共享它的状态，但并不保证整个应用程序的实例的唯一性。在分析解析算法时，一个模块可能会多次安装在应用程序的依赖关系树中。这导致了同一逻辑模块的多个实例，所有这些实例都运行在同一个Node.js应用程序的上下文中。

require加载模块

根据CommonJS规范的要求，Node.js使用内置的require命令加载模块。

const example = require('./example.js');

通过下面的函数来看看require函数究竟做了哪些事情：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
const require = (moduleName) => {
  console.log(`Require invoked for module: ${moduleName}`);
  const id = require.resolve(moduleName);  // 输入函数名，返回模块的完整路径，该路径用于加载代码和标识模块
  // 是否命中缓存
  if (require.cache[id]) {
    return require.cache[id].exports;
  }
  // 定义module
  const module = {
    exports: {},
    id: id
  };
  // 新模块引入，存入缓存
  require.cache[id] = module;
  // 加载模块
  loadModule(id, module, require);
  // 返回导出的变量
  return module.exports;
};
require.cache = {};
require.resolve = (moduleName) => {
  /* 通过模块名作为参数resolve一个完整的模块 */
};

加载基本规则

使用require加载模块，加载时就会执行：

  • 文件路径：/表示绝对路径，./表示相对路径，无/或./表示加载Node核心模块或node_modules中的第三方模块
  • 文件后缀：(无后缀)Node会尝试为文件添加.js，.json，.node后搜索解析

加载缓存

Node在第一次加载某个模块时，会缓存该模块，以后再加载该模块，就直接从缓存取出module.exports属性。并且 CommonJS模块的加载机制是，输入的是被输出的值的拷贝。也就是说，一旦输出一个值，模块内部的变化就影响不到这个值。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// cache.js
var testVal = 100;

function test() {
  testVal++;
  console.log(testVal);
}
module.exports.testVal = testVal;
module.exports.testFn = test;

// main.js
const mod = require('./cache.js');
console.log(mod.testVal);  // 100
mod.testFn();  // 101
console.log(mod.testVal);  // 100

所有缓存的模块保存在require.cache之中，如果想删除模块的缓存，可以像下面这样写。

1
2
3
4
5
// 删除指定模块的缓存
delete require.cache[moduleName];

// 删除所有模块的缓存Object.keys(require.cache).forEach(function(key) {
delete require.cache[key];})

循环加载

如果发生模块的循环加载，即A加载B，B又加载A，则B将加载A的不完整版本。也就是说，一旦出现某个模块被循环加载，就只输出已执行的部分，还未执行的部分不会输出

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// modeA.js
module.exports.test = 'A';
const modB = require('./modB');
console.log('modA: ', modB.test); // modA: BB
module.exports.test = 'AA';

// modeB.js
module.exports.test = 'B';
const modA = require('./modA');
console.log('modB: ', modA.test); // modB: A
module.exports.test = 'BB';

// main.js
const modA = require('./modA');
const modB = require('./modB');
console.log(modA.test);  // 'AA'
console.log(modB.test);  // 'BB'

上述代码的执行过程：

  • 执行node main.js运行main模块
  • require模块A，开始执行模块A
  • 模块A暴露出test值为A
  • 模块A require模块B，开始执行模块B
  • 模块B暴露出test值为B
  • 模块B require模块A，此时直接取缓存，并不会继续执行模块A，因此输出modB: A
  • 模块B覆盖test值为BB
  • 模块B执行完毕之后，继续执行模块A，此时输出modA: BB
  • 模块A覆盖test值为AA
  • main模块require 模块B，直接取缓存
  • 最后输出’AA’，’BB’

摘自简书：
作者：我不是黄悠然
链接：https://www.jianshu.com/p/d187da728f90
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。