CommonJS是Node.js使用的模块化标准，在CommonJS规范中，一个文件就是一个模块，模块具有单独的作用域，在模块内定义的变量、函数、类等都是私有的，对其他文件不可见。
exports定义模块
在CommonJS中使用exports定义模块。
// exapmle.js
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对象添加方法。
exports.dosth = function() { ... }
// 等同于
module.exports.dosth = function() { ... }
// 另一种写法
function dosth() { ... }
module.exports.dosth = dosth;
在使用exports时必须要注意一点！！！就是不能修改exports的指向。
// 以下定义方式改变了exports的指向，exports对象会被当做普通的函数/对象
// 外部无法通过require获取
exports = function() { ... }
exports = {
xx: 1
}
建议统一使用module.exports。
定义模块的几种方式
命名导出
暴露API的最基本方法，将所有要公开的值作为属性赋给exports对象。
exports.xxx = () => { ... }
导出函数
将整个module.exports变量重新分配给一个函数，主要优点是只暴露一个单一的功能，这为模块提供了一个明确的入口点，使其更容易理解和使用。
module.exports = () => { ... }
导出构造函数
导出构造函数的模块是导出函数的模块的特例。其不同之处在于，使用这种新模式，我们允许用户使用构造函数创建新的实例，但是我们也可以扩展其原型并创建新类（继承）。以下是此模式的示例：
// file logger.js
function Logger(name) {
this.name = name;
}
Logger.prototype.log = function(message) {
console.log(`[${this.name}] ${message}`);
};
module.exports = Logger;
我们通过以下方式使用上述模块：
// file main.js
const Logger = require('./logger');
const dbLogger = new Logger('DB');
dbLogger.log('...');
我们还可以使用ES6提供的class类实现上述代码。
导出实例
我们可以利用require()的缓存机制来轻松地定义具有从构造函数或工厂创建的状态的有状态实例，可以在不同模块之间共享。以下代码显示了此模式的示例：
//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');
这个新定义的模块可以这么使用：
// 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函数究竟做了哪些事情：
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一个完整的模块 */
};
加载基本规则
- 文件路径：/表示绝对路径，./表示相对路径，无/或./表示加载Node核心模块或node_modules中的第三方模块
- 文件后缀：(无后缀)Node会尝试为文件添加.js，.json，.node后搜索解析
- 使用require加载模块，加载时就会执行
加载缓存
Node在第一次加载某个模块时，会缓存该模块，以后再加载该模块，就直接从缓存取出module.exports属性。并且 CommonJS模块的加载机制是，输入的是被输出的值的拷贝。也就是说，一旦输出一个值，模块内部的变化就影响不到这个值。
// 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之中，如果想删除模块的缓存，可以像下面这样写。
// 删除指定模块的缓存
delete require.cache[moduleName];
// 删除所有模块的缓存Object.keys(require.cache).forEach(function(key) {
delete require.cache[key];})
循环加载
如果发生模块的循环加载，即A加载B，B又加载A，则B将加载A的不完整版本。也就是说，一旦出现某个模块被循环加载，就只输出已执行的部分，还未执行的部分不会输出。
// 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'
