模块分类
Node.js有两种模块
- 外围模块
局部外围模块曾经被间接加载进内存中,路径分析 编译执行的步骤能够省略 并且在路径分析中优先被判断,所以加载速度最快 - 文件模块
运行时动静加载,所以须要残缺的路径分析 文件定位和 编译执行过程,所以速度比外围模块慢
实现“模块”性能的奥秘就在于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);
整个具体的过程剖析如下:
- node main.js
- require a.js,load a.js,输入“a starting“
- a: exports.done = false,require b.js,load b.js
- 输入”b starting“,b: exports.done = false
- require a.js, 因为a.js没有执行完,将未实现的正本导出,所以 a = {done: false}
- 输入in b, a.done = false
- b: exports.done = true,输入b done,b.js执行结束,返回a.js继续执行
- b = { done: true },输入in a, b.done = true,输入a done
- a.js 执行结束,a = { done: true } ,返回 main.js 继续执行,require b.js
- 因为 b.js 曾经被执行结束,缓存中拿值,当初 a = { done: true }, b = { done: true }
- 输入in main, a.done = true, b.done = true
由此可见,Node.js对已加载过的模块进行缓存,解决了循环援用的问题,在二次加载时间接从缓存中取,进步了加载速度。
路径分析和文件定位
咱们须要理解,自定义模块是动静加载的(运行时加载),在首次加载时,要通过路径分析、文件定位、编译执行的过程。
在剖析门路模块时,require()
办法会去查找实在的门路
- 如果没有扩展名,会依照剖析程序:.js > .node > .json 顺次进行匹配
- 如果没有查找到对应的文件,然而失去的是一个目录,那么会被当成一个包来解决
优先查找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 模块机制不齐全指北