咱们都晓得 Nodejs 遵循的是 CommonJS
标准,当咱们 require('moduleA')
时,模块是怎么通过名字或者门路获取到模块的呢?首先要聊一下模块援用、模块定义、模块标识三个概念。
1 CommonJS
标准
1.1 模块援用
模块上下文提供 require()
办法来引入内部模块,看似简略的 require 函数,其实外部做了大量工作。示例代码如下:
//test.js
// 引入一个模块到以后上下文中
const math = require('math');
math.add(1, 2);
1.2 模块定义
模块上下文提供了 exports
对象用于导入导出以后模块的办法或者变量,并且它是惟一的导出进口。模块中存在一个 module
对象,它代表模块本身,exports
是 module 的属性。一个文件就是一个模块,将办法作为属性挂载在 exports 上就能够定义导出的形式:
//math.js
exports.add = function () {
let sum = 0, i = 0, args = arguments, l = args.length;
while(i < l) {sum += args[i++];
}
return sum;
}
这样就可像 test.js
里那样在 require()之后调用模块的属性或者办法了。
1.3 模块标识
模块标识就是传递 给 require()
办法的参数,它必须是合乎小驼峰命名的字符串,或者以 .
、..
结尾的相对路径或者绝对路径,能够没有文件后缀名.js
.
2. Node 的模块实现
在 Node 中引入模块,须要经验如下四个步骤:
- 路径分析
- 文件定位
- 编译执行
- 退出内存
2.1 路径分析
Node.js 中模块能够通过文件门路或名字获取模块的援用。模块的援用会映射到一个 js 文件门路。在 Node 中模块分为两类:
- 一是 Node 提供的模块,称为 外围模块(内置模块),内置模块公开了一些罕用的 API 给开发者,并且它们在 Node 过程开始的时候就预加载了。
- 另一类是用户编写的模块,称为 文件模块。如通过 NPM 装置的第三方模块(third-party modules)或本地模块(local modules),每个模块都会裸露一个公开的 API。以便开发者能够导入。如
const mod = require('module_name')
const {methodA} = require('module_name')
执行后,Node 外部会载入内置模块或通过 NPM 装置的模块。require 函数会返回一个对象,该对象公开的 API 可能是函数、对象或者属性如函数、数组甚至任意类型的 JS 对象。
外围模块是 Node 源码在编译过程中编译进了二进制执行文件。在 Node 启动时这些模块就被加载进内存中,所以外围模块引入时省去了文件定位和编译执行两个步骤,并且在路径分析中优先判断,因而外围模块的加载速度是最快的。文件模块则是在运行时动静加载,速度比外围模块慢。
这里列下 node 模块的载入及缓存机制:
1、载入内置模块(A Core Module)
2、载入文件模块(A File Module)
3、载入文件目录模块(A Folder Module)
4、载入 node_modules 里的模块
5、主动缓存已载入模块
1、载入内置模块
Node 的内置模块被编译为二进制模式,援用时间接应用名字而非文件门路。当第三方的模块和内置模块同名时,内置模块将笼罩第三方同名模块。因而命名时须要留神不要和内置模块同名。如获取一个 http 模块
const http = require('http')
返回的 http 即是实现了 HTTP 性能 Node 的内置模块。
2、载入文件模块
绝对路径的
const myMod = require('/home/base/my_mod')
或相对路径的
const myMod = require('./my_mod')
留神,这里疏忽了扩展名.js
,以下是对等的
const myMod = require('./my_mod')
const myMod = require('./my_mod.js')
3、载入文件目录模块
能够间接 require 一个目录,假如有一个目录名为 folder,如
const myMod = require('./folder')
此时,Node 将搜寻整个 folder 目录,Node 会假如 folder 为一个包并试图找到包定义文件 package.json。如果 folder 目录里没有蕴含 package.json
文件,Node 会假如默认主文件为 index.js
,即会加载index.js
。如果index.js
也不存在,那么加载将失败。
4、载入 node_modules 里的模块
如果模块名不是门路,也不是内置模块,Node 将试图去当前目录的 node_modules
文件夹里搜寻。如果当前目录的 node_modules
里没有找到,Node 会从父目录的 node_modules
里搜寻,这样递归上来直到根目录。
5、主动缓存已载入模块
对于已加载的模块 Node 会缓存下来,而不用每次都从新搜寻。上面是一个示例
// modA.js
console.log('模块 modA 开始加载...')
exports = function() {console.log('Hi')
}
console.log('模块 modA 加载结束')
//init.js
var mod1 = require('./modA')
var mod2 = require('./modA')
console.log(mod1 === mod2)
命令行 node init.js
执行:
模块 modA 开始加载...
模块 modA 加载结束
true
能够看到尽管 require 了两次,但 modA.js 依然只执行了一次。mod1 和 mod2 是雷同的,即两个援用都指向了同一个模块对象。
优先从缓存加载
和浏览器会缓存动态 js 文件一样,Node 也会对引入的模块进行缓存,不同的是,浏览器仅仅缓存文件,而 nodejs 缓存的是编译和执行后的对象(缓存内存 )require()
对雷同模块的二次加载一律采纳缓存优先的形式,这是第一优先级的,外围模块缓存查看先于文件模块的缓存查看。
基于这点:咱们能够编写一个模块,用来记录长期存在的变量。例如:我能够编写一个记录接口拜访数的模块:
let count = {}; // 因模块是关闭的,这里实际上借用了 js 闭包的概念
exports.count = function(name){if(count[name]){count[name]++;
}else{count[name] = 1;
}
console.log(name + '被拜访了' + count[name] + '次。');
};
咱们在路由的 action
或 controller
里这样援用:
let count = require('count');
export.index = function(req, res){count('index');
};
以上便实现了对接口调用数的统计,但这只是个 demo,因为数据存储在内存,服务器重启后便会清空。真正的计数器肯定是要联合长久化存储器的。
在进入门路查找之前有必要形容一下 module path
这个 Node.js 中的概念。对于每一个被加载的文件模块,创立这个模块对象的时候,这个模块便会有一个 paths 属性,其值依据以后文件的门路 计算失去。咱们创立 modulepath.js
这样一个文件,其内容为:
// modulepath.js
console.log(module.paths);
咱们将其放到任意一个目录中执行 node modulepath.js 命令,将失去以下的输入后果。
[ '/home/ikeepstudying/research/node_modules',
'/home/ikeepstudying/node_modules',
'/home/node_modules',
'/node_modules' ]
参考 nodejs 进阶视频解说:进入学习
2.2 文件定位
1. 文件扩展名剖析
调用 require()
办法时若参数没有文件扩展名,Node 会按 .js
、.json
、.node
的顺寻补足扩展名,顺次尝试。
在尝试过程中,须要调用 fs 模块阻塞式 地判断文件是否存在。因为 Node 的执行是单线程的,这是一个会引起性能问题的中央。如果是 .node
或者·.json·文件能够加上扩展名放慢一点速度。另一个窍门是:同步配合缓存。
2. 目录剖析和包
require()
剖析文件扩展名后,可能没有查到对应文件,而是找到了一个目录,此时 Node 会将目录当作一个包来解决。
首先,Node 在挡墙目录下查找 package.json
,通过JSON.parse()
解析出包形容对象,从中取出 main 属性指定的文件名进行定位。若 main 属性指定文件名谬误,或者没有 pachage.json
文件,Node 会将 index 当作默认文件名。
简而言之,如果 require
绝对路径的文件,查找时不会去遍历每一个 node_modules
目录,其速度最快。其余流程如下:
1. 从 module path
数组中取出第一个目录作为查找基准。
2. 间接从目录中查找该文件,如果存在,则完结查找。如果不存在,则进行下一条查找。
3. 尝试增加 .js
、.json
、.node
后缀后查找,如果存在文件,则完结查找。如果不存在,则进行下一条。
4. 尝试将 require
的参数作为一个包来进行查找,读取目录下的 package.json
文件,获得 main
参数指定的文件。
5. 尝试查找该文件,如果存在,则完结查找。如果不存在,则进行第 3 条查找。
6. 如果持续失败,则取出 module path
数组中的下一个目录作为基准查找,循环第 1 至 5 个步骤。
7. 如果持续失败,循环第 1 至 6 个步骤,直到 module path 中的最初一个值。
8. 如果依然失败,则抛出异样。
整个查找过程非常相似原型链的查找和作用域的查找。所幸 Node.js 对门路查找实现了缓存机制,否则因为每次判断门路都是同步阻塞式进行,会导致重大的性能耗费。
一旦加载胜利就以模块的门路进行缓存
2.3 模块编译
每个模块文件模块都是一个对象,它的定义如下:
function Module(id, parent) {
this.id = id;
this.exports = {};
this.parent = parent;
if(parent && parent.children) {parent.children.push(this);
}
this.filename = null;
this.loaded = false;
this.children = [];}
对于不同扩展名,其载入办法也有所不同:
.js
通过 fs 模块同步读取文件后编译执行。.node
这是 C /C++ 编写的扩大文件,通过dlopen()
办法加载最初编译生成的文件.json
同过 fs 模块同步读取文件后,用JSON.pares()
解析返回后果
其余当作.js
每一个编译胜利的模块都会将其文件门路作为索引缓存在 Module._cache
对象上。
json
文件的编译
.json
文件调用的办法如下: 其实就是调用JSON.parse
//Native extension for .json
Module._extensions['.json'] = function(module, filename) {var content = NativeModule.require('fs').readFileSync(filename, 'utf-8');
try {module.exports = JSON.parse(stripBOM(content));
} catch(err) {
err.message = filename + ':' + err.message;
throw err;
}
}
Module._extensions
会被赋值给 require()
的extensions
属性,所以能够用:console.log(require.extensions)
; 输入零碎中已有的扩大加载形式。
当然也能够本人减少一些非凡的加载:
require.extensions['.txt'] = function(){//code};。
然而官网不激励通过这种形式自定义扩展名加载,而是冀望先将其余语言或文件编译成 JavaScript 文件后再加载,这样的益处在于不讲繁缛的编译加载等过程引入 Node 的执行过程。
js
模块的编译 在编译的过程中,Node 对获取的 javascript 文件内容进行了头尾包装,将文件内容包装在一个 function 中:
(function (exports, require, module, __filename, __dirname) {var math = require(‘math‘);
exports.area = function(radius) {return Math.PI * radius * radius;}
})
包装之后的代码会通过 vm 原生模块的 runInThisContext()
办法执行(具备明确上下文,不净化全局),返回一个具体的 function 对象,最初传参执行,执行后返回module.exports
.
外围模块编译
外围模块分为 C/C++
编写和 JavaScript 编写的两个局部,其中 C/C++
文件放在 Node 我的项目的 src 目录下,JavaScript 文件放在 lib 目录下。
1. 转存为 C /C++ 代码
Node 采纳了 V8 附带的 js2c.py 工具,将所有内置的 JavaScript 代码转换成 C ++ 里的数组,生成 node_natives.h 头文件:
namespace node {const char node_native[] = {47, 47, ..};
const char dgram_native[] = { 47, 47, ..};
const char console_native = {47, 47, ..};
const char buffer_native = {47, 47, ..};
const char querystring_native = {47, 47, ..};
const char punycode_native = {47, 47, ..};
...
struct _native {
const char* name;
const char* source;
size_t source_len;
}
static const struct _native natives[] = {{ "node", node_native, sizeof(node_native)-1},
{"dgram", dgram_native, sizeof(dgram_native)-1},
...
};
}
在这个过程中,JavaScript 代码以字符串模式存储在 node 命名空间中, 是不可间接执行的。在启动 Node 过程时,js 代码间接加载到内存中。在加载的过程中,js 外围模块经验标识符剖析后间接定位到内存中。
2. 编译 js 外围模块
lib 目录下的模块文件也在引入过程中经验了头尾包装的过程,而后才执行和导出了 exports 对象。与文件模块的区别在于:获取源代码的形式(外围模块从内存加载)和缓存执行后果的地位。
js 外围模块源文件通过 process.binding('natives')
取出,编译胜利的模块缓存到 NativeModule._cache
上。代码如下:
function NativeModule() {
this.filename = id + '.js';
this.id = id;
this.exports = {};
this.loaded = fales;
}
NativeModule._source = process.binding('natives');
NativeModule._cache = {};
3 import
和require
简略的说一下 import
和require
的本质区别
import
是 ES6 的模块标准,require
是 commonjs 的模块标准,具体的用法我不介绍,我只想说一下他们最根本的区别,import 是动态 (编译时) 加载模块,require(运行时)是动静加载,那么动态加载和动静加载的区别是什么呢?
动态加载时代码在编译的时候曾经执行了,动静加载是编译后在代码运行的时候再执行,那么具体点是什么呢?
先说说 import,如下代码
import {name} from 'name.js'
// name.js 文件
export let name = 'jinux'
export let age = 20
下面的代码示意 main.js
文件里引入了 name.js
文件导出的变量,在代码编译阶段执行后的代码如下:
let name = 'jinux'
这个是我本人了解的,其实就是间接把 name.js
里的代码放到了 main.js
文件里,好比是在 main.js
文件中申明一样。
再来看看 require
var obj = require('obj.js');
// obj.js 文件
var obj = {
name: 'jinux',
age: 20
}
module.export obj;
require 是在运行阶段,须要把 obj 对象整个加载进内存,之后用到哪个变量就用哪个,这里再比照一下 import
,import
是动态加载,如果只引入了 name,age 是不会引入的,所以是按需引入,性能更好一点。
4 nodejs 革除 require 缓存
开发 nodejs 利用时会面临一个麻烦的事件,就是批改了配置数据之后,必须重启服务器能力看到批改后的后果。
于是问题来了,挖掘机哪家强?噢,no! no! no! 怎么做到批改文件之后,主动重启服务器。
server.js
中的片段:
const port = process.env.port || 1337;
app.listen(port);
console.log("server start in" + port);
exports.app = app;
假设咱们当初是这样的, app.js 的片段:
const app = require('./server.js');
如果咱们在 server.js 中启动了服务器,咱们进行服务器能够在 app.js 中调用
app.app.close()
然而当咱们从新引入 server.js
app = require('./server.js')
的时候会发现并不是用的最新的 server.js 文件,起因是 require 的缓存机制,在第一次调用 require('./server.js')
的时候缓存下来了。
这个时候怎么办?
上面的代码解决了这个问题:
delete require.cache[require.resolve('./server.js')];
app = require('./server.js');