深入浅出Node.js模块机制

模块分类

Node.js有两种模块

1. 核心模块
   部分核心模块已经被直接加载进内存中，路径分析 编译执行的步骤可以省略 并且在路径分析中优先被判断，所以加载速度最快
2. 文件模块
   运行时动态加载，所以需要完整的路径分析 文件定位和 编译执行过程，所以速度比核心模块慢

实现“模块”功能的奥妙就在于JavaScript是一种函数式编程语言，它支持闭包。如果我们把一段JavaScript代码用一个函数包装起来，这段代码的所有“全局”变量就变成了函数内部的局部变量。

var s = 'Hello';
var name = 'world';

console.log(s + ' ' + name + '!');

(function() {
    var s = 'Hello';
    var name = 'world';
    
    console.log(s + ' ' + name + '!');
})()

这样一来，原来的全局变量s现在变成了匿名函数内部的局部变量。如果Node.js继续加载其他模块，这些模块中定义的“全局”变量s也互不干扰。

所以，Node利用JavaScript的函数式编程的特性，轻而易举地实现了模块的隔离。

模块缓存机制

Nodejs对加载过的模块 会进行缓存，以减少二次引入时的开销，引入模块时会优先从缓存中查找，Node缓存的是编译和执行之后的对象

缓存形式： key-value的形式，以真实路径作为key，以编译执行后的结果作为value 放在缓存中（Module._cache对象中）（二次加载速度更快）
打印rquire.cache 可以看到缓存的对象

模块的循环引用

先说结论，由于Node.js会缓存加载过的模块，所有模块的循环依赖并不会引起无限循环引用。举个例子：

a.js文件下

console.log('a starting');
exports.done = false

const b = require('./b.js')
console.log('in a, b done = %j', b.done);

exports.done = true
console.log('a done');

b.js文件下

console.log('b starting');
exports.done = false

// 这里导入的是a未执行完的副本
const a = require('./a.js')
console.log('in b, a done = %j', a.done);

exports.done = true
console.log('b done');

main.js文件下

console.log('main starting');
const a = require('./a')
const b = require('./b')

console.log('in main.js, a done = %j, b done = %j', a.done, b.done);

整个详细的过程分析如下：

1. node main.js
2. require a.js，load a.js，输出“a starting“
3. a: exports.done = false，require b.js，load b.js
4. 输出”b starting“，b: exports.done = false
5. require a.js， 由于a.js没有执行完，将未完成的副本导出，所以 a = {done: false}
6. 输出in b, a.done = false
7. b: exports.done = true，输出b done，b.js执行完毕，返回a.js继续执行
8. b = { done: true }，输出in a, b.done = true，输出a done
9. a.js 执行完毕，a = { done: true } ，返回 main.js 继续执行，require b.js
10. 由于 b.js 已经被执行完毕，缓存中拿值，现在 a = { done: true }， b = { done: true }
11. 输出in main, a.done = true, b.done = true

由此可见，Node.js对已加载过的模块进行缓存，解决了循环引用的问题，在二次加载时直接从缓存中取，提高了加载速度。

路径分析和文件定位

我们需要了解，自定义模块是动态加载的（运行时加载），在首次加载时，要经过路径分析、文件定位、编译执行的过程。

在分析路径模块时，require()方法会去查找真实的路径

1. 如果没有扩展名，会按照分析顺序：.js > .node > .json 依次进行匹配
2. 如果没有查找到对应的文件，但是得到的是一个目录，那么会被当成一个包来处理
   优先查找package.json中main属性指定的文件名进行定位 > index.js > index.node > index.json 依次匹配

模块的编译

编译和执行是引入文件模块的最后一个阶段。这里只讲对.js文件的编译，通过fs模块同步读取文件后进行编译，每个编译成功的模块都会以它的真实路径作为索引缓存在Module._cache对象上，以提高二次引入的性能。

编译过程中，Node会对获取到的文件进行头尾包装

(function(module, exports, require, __filename, __dirname) {
    
})

这样每个模块之间都进行了作用域隔离 也解释了我们没有在模块文件中定义module、exports、__filename、 __dirname这些变量却可以使用它们的原因。

module.exports和exports的区别

Node.js在执行一个javascript文件时，会生成一个module和exports对象, module还有一个exports属性，module.exports和exports指向同一个引用
两者的根本区别是：
exports返回的是模块函数，module.exports返回的是模块对象本身
举个例子：
a.js文件下

let sayHello = function() {
    console.log('hello');
}
exports.sayHello = sayHello

b.js文件下

// 这样使用会报错
const sayHello = require('./a')
sayHi()

// 正确的方式
const func = require('./a')
func.sayHello() // hello

新建c.js文件

let sayHello = function() {
    console.log('hello');
}
// 1方式导出
module.exports.sayHello = sayHello
// 2方式导出
module.exports = sayHello

在b.js中引入

// 1方式的
const func = require('./a')
func.sayHello() // hello

// 2方式的
const sayHello = require('./a')
sayHello() // hello

可以看出，1方式的导出跟exports的导出，在引入时的方式是一致的

module.exports.sayHello = sayHello
等同于
module.exports = {
   sayHello: sayHello
}
也等同于
exports.sayHello = sayHello

还有一个注意的点是：执行require()方法时，引入的是module.exports导出的内容。

// d.js文件下：
exports = {
    a: 200
}
module.exports = {
    a: 100
}

// b.js引入
const value = require('./d')
console.log('value', value); // {a: 100}

从上面可以看出，其实require导出的内容是module.exports的指向的内存块内容，并不是exports的。

// 如果d.js文件变成
exports = {
    a: 200
}

// b.js引入
const value = require('./d')
console.log('value', value); // {}

可以看到打印出来的值为{} 那是因为exports本来指向跟module.exports同一个引用，现在exports = {a: 200} exports指向了另一个内存地址，将与module.exports脱离关系，默认module.eports={}

总结

• exports 是 module.exports 的一个引用
• module.exports 初始化是一个{}，exports 也是这个{}
• require 引用返回的是 module.exports，而不是 exports
• exports.xxx = xxxx 相当于在导出对象上直接添加属性或者修改属性值，在调用模块直接可见
• exports = xxx 为 exports 重新分配内存，将脱离 module.exports ，两者无关联。调用模块将不能访问。

参考：
Node 模块机制不完全指北