Nodejs模块加载与ES6模块加载实现

时间  2020-01-15 标签 nodejs 模块 加载 es6 实现

原始时代

做为一门语言的引入代码方式，相较于其余如PHP的include和require，Ruby的require，Python的import机制，Javascript是直接使用 <script> 标签。
由于Javascript是一门单线程语言，GUI渲染线程和Javascript引擎线程是互斥的，代码执行 <script> 标签GUI渲染线程会挂起，而后下载资源，执行脚本，完成以后再继续往下执行。在那段时间内界面是不会响应用户操做的。用户体验至关不友好。同时还带来一系列的隐患:javascript

  • 引入顺序可能会引发代码无效甚至报错;
  • 互不了解的代码也许会形成重复命名覆盖;
  • 难以串联代码之间逻辑关系;
  • 执行顺序受影响的因素更多;
  • 不易管理维护;

<script> 标签也提供了 defer 和 async 属性能够实现异步加载。渲染引擎遇到这一行命令，就会开始下载外部脚本，但不会等它下载和执行，而是直接执行后面的命令，区别在于:html

  • defer: 等到整个页面在内存中正常渲染结束（DOM结构彻底生成，以及其余脚本执行完成），才会执行，能够保证顺序加载;
  • async: 一旦下载完，渲染引擎就会中断渲染，执行这个脚本之后，再继续渲染，不保证顺序加载;
<script src="xx.js" defer></script>
<script src="xx.js" async></script>

出于须要社区制定了一些模块加载方案，最主要的有 CommonJS 和 AMD 两种。前者用于服务器，后者用于浏览器。java

CommonJS规范

CommonJS规范为Javascript制定的美好愿景是但愿Javascript可以在任何地方运行，具有跨宿主环境执行的能力，例如:node

  • 富客户端应用
  • 服务器端Javascript应用程序（如Nodejs ）
  • 命令行工具
  • 桌面图形界面应用程序
  • 混合应用（Titanium和Adobe AIR等形式应用）

这些规范基本覆盖了模块，二进制，Buffer，字符集编码，I/O流，进程环境，文件系统，套接字，单元测试，Web服务器网关接口，包管理等。git

模块规范

1， 引用
模块上下文提供 require() 方法引入外部模块，通常以下es6

var fs = require('fs');

2， 定义
模块中存在一个上下文 module对象 ，它表明模块自身， module对象 提供了 exports对象 用于导出当前模块的变量、函数、类，而且是惟一的导出出口。json

//a.js模块
exports.a = 1;
//引用a.js模块
var a = require('a');

3， 标识
require() 方法接受小驼峰命名的字符串，或者相对/绝对路径，而且能够省略文件后缀，它有本身一套匹配规则，后面再讲。数组

  • "./" 开头表示相对路径引用模块;
  • "/" 开头表示绝对路径引用模块;
  • 不带上面符号开头的小驼峰字符串表示默认提供的核心模块或者 node_modules 下安装模块;
  • 不带上面符号开头的路径字符串表示 node_modules 下安装模块对应后续路径;
//a.js模块
var a = require('./a');
var a = require('/a');
var a = require('a');
var a = require('a/a');

至此看来使用至关简单，模块的意义在于将类聚的变量、函数、类等限定在私有做用域中，同时支持引入导出功能链接上下游依赖，避免了变量污染等问题。浏览器

module.exports 和exports的关系?

exports 是引用 module.exports 的值，而真正导出的是 module.exports ，接着就是基本类型和引用类型的区别。
若是直接替换 module.exports 或者exports至关于切断了和原有对象之间的关联，后续二者互不影响了。缓存

CommonJS加载原理

第一次 require() 一个脚本的时候会执行代码而后在内存中会生成一个模块对象缓存起来，相似

{
  id: '...',//模块的识别符，一般是带有绝对路径的模块文件名
  filename: '',//模块的文件名，带有绝对路径
  exports: {...},//导出变量、函数、类
  loaded: true,//模块是否已经完成加载
  parent: {},//调用该模块的模块
  children: [],//该模块要用到的其余模块
  ...
}

例如你建立一个文件脚本代码执行就能够查看到这些信息。

exports.a = 1;
console.log(module);
// Module {
//   id: '.',
//   exports: { a: 1 },
//   parent: null,
//
//   filename: 'C:\\project\\test\\module_demo\\test1.js',
//   loaded: false,
//   children: [],
//   paths:
//    [ 'C:\\project\\test\\module_demo\\node_modules',
//      'C:\\project\\test\\node_modules',
//      'C:\\project\\node_modules',
//      'C:\\node_modules' ] }

之后须要引用模块的变量、函数、类就在这个模块对象的 exports 取出，即便再次 require() 进来模块也不会从新执行，只会从缓存获取。

CommonJS优势

  • 模块引用顺序决定加载顺序；
  • 每一个模块只会加载一次，而后将运行结果缓存起来二次利用，之后再次加载就直接读取缓存。要想让模块再次运行，必须清除缓存；
  • 每一个模块都有其单独的做用域，不会污染全局；

Nodejs 模块实现

Nodejs 借鋻了 CommonJS 但不彻底按照规范实现了本身的模块系统。

在Nodejs 引入模块会经历三个步骤:

  • 路径分析;
  • 文件定位;
  • 编译执行;

在 Nodejs 中有两种模块

  • Nodejs 提供的核心模块;
    这部分模块在 Nodejs 源代码编译过程当中编译进了二进制执行文件。在 Nodejs 进程启动时部分核心模块被直接加载进了内存中，因此在引用的时候能够省去文件定位和编译执行的步骤，而且在路径分析优先判断，因此加载速度是最快的。
  • 由用户编写的文件模块;
    这部分模块在运行时动态加载，须要经历完整步骤。

Nodejs 会对引用过的模块进行缓存以减小二次引入的开销。并且缓存的是模块编译和执行以后的对象。因此 require() 对相同模块的再次加载都是优先缓存方式，核心模块的缓存检查依然优先于文件模块。

Nodejs 模块标识

前面提过的模块标识，例如:

  • 核心模块fs等
    优先级仅次于缓存加载，若是直接引用本身编写的和核心模块具备相同标识的模块会引用失败，必须选择不一样标识符或者使用路径方式加载。
  • 路径形式文件模块
    分析过程当中 rerquire() 会将路径转换成真实路径，并以此为索引将编译后结果缓存起来，由于指明了模块位置因此查找过程会省点时间，速度慢于核心模块。
  • 自定义模块
    多是以包或者文件形式的特殊模块，查找费时速度最慢的一种，由于他会用到模块路径的查找方法。

模块路径规则

Nodejs在定位文件模块有本身的一套查找策略，你能够随便一个文件夹执行一个脚本以下看看打印信息，我是 Windows 系统结果以下

console.log(module.paths);
// [ 'C:\\work\\project\\test\\node_modules',
//   'C:\\work\\project\\node_modules',
//   'C:\\work\\node_modules',
//   'C:\\node_modules' ]

从中能够看出他会从当前执行文件所在目录下的 node_modules，沿路径向上逐层递归查找 node_modules 直到根目录为止。
模块加载过程会逐个尝试直到符合条件或者没有符合为止，你能够看出里面有着很明显的问题。

  • 层级越深查找起来越费时费力;
  • 可能你衹想查看当前目录，可是它失败后会自动尝试其余路径;

这就是自定义模块最慢的缘由。

文件定位

  • 扩展名分析
    Nodejs 在标识符不包含后缀状况下会以.js， .json， .node的次序逐个尝试匹配，并且过程当中须要利用fs模块以同步阻塞方式去判断是否匹配，因此在非.js文件状况指明后缀能减小性能损耗的问题。
  • 目录分析和包
    还有一种状况是通过上面步骤以后都匹配不到对应文件可是有符合的目录，此时Nodejs 会将其做为一个包的方式处理。
    1）查找包下的 package.json 文件（包描述文件），经过 JSON.parse() 解析出文件读取里面的 main 属性定位对应的文件,省略后缀状况下须要执行扩展名分析步骤。
    2）若是没有 package.json 或者 main 属性不对，会用默认值 index 去查找匹配文件，这一步须要扩展名分析步骤逐个尝试。
    3）若是仍是失败就会根据模块路径规则往上层路径寻找，直到所有路径都没有匹配文件就抛出失败。

模块编译

这是引入模块的最后阶段，定位到目标文件以后会新建一个模块对象，而后根据路径载入进行编译，不一样后缀文件载入方式不一样:

  • js经过fs模块同步读取文件以后编译执行；
  • node是C/C++编写的扩展文件，经过 dlopen()方法 加载最后编译生成的对象；
  • json经过fs模块同步读取文件以后用 JSON.parse() 解析返回结果；
  • 其他默认js处理方式；

每一个编译成功以后的模块都会以其文件路径做为索引缓存在 Module_cache。根据不一样的扩展后缀 Nodejs 有不一样的读取方式。

1， Javascript模块编译
在编译过程当中，Nodejs 会对获取的模块进行包装，以下:

(function(exports, require, module, __filename, __dirname) {
    //模块源码
})

2， C/C++模块编译
Nodejs 调用 process.dlopen() 方法进行加载执行，经过 libuv封装库 支持 Windows 和 *nix 平台下实现，由于.node自己就是C/C++写的，因此它不须要编译，衹要加载执行就能够了，执行效率较高。

3， JSON文件编译
上面说过经过fs模块同步读取文件以后用 JSON.parse() 解析返回结果，赋值给模块对象的 exports。
除了配置文件，若是你开发中有须要用到json文件的时候能够不用 fs模块 去读取，而是直接 require() 引入更好，由于能享受到缓存加载的便利。

核心模块

上面说过 Nodejs 模块分为核心模块和文件模块，刚才讲的都是文件模块的编译过程，而 Nodejs 的核心模块在编译成可执行文件过程当中会被编译进二进制文件。核心模块也分Javascript和C/C++编写，前者在Node的lib目录，后者在Node的src目录。

Javascript核心模块编译

转存为C/C++代码

Nodejs 采用V8附带的 js2c.py工具 将内置的Javascript代码（src/node.js和lib/*.js）转成C++的数组，生成 node_natives.h 头文件，Javascript代码以字符串形式存储在nodejs命名空间里，此时还不能直接执行。等 Nodejs 启动进程时候才被直接加载进内存中，因此不须要引入就能直接使用。

编译Javascript核心模块

和文件模块同样也会被包装成模块对象，区别在于获取源代码的方式以及缓存执行结果的位置。
核心模块源文件经过 process.binding('natives') 取出，编译完成后缓存到 NativeModule._cache 对象上，而文件模块会被缓存到 Module._cache。

C/C++核心模块编译（不懂C/C++，这一块简短略过）

内建模块的组织形式

每一个内建模块在定义以后会经过 NODE_MODULE宏 将模块定义到nodejs命名空间，模块的具体初始化方法被挂载在结构的 register_func 成员。
node_extensions.h 文件将散列的内建模块统一放进 node_module_list数组 中，Nodejs 提供了 get_builtin_module() 方法从中取出。
内建模块优点在于自己C/C++编写性能优异，编译成二进制文件时候被直接加载进内存，无需再作标识符定位，文件定位，编译等过程。

内建模块导出

Nodejs 启动会生成全局变量 process，提供 Binding() 方法协助加载内建模块。
加载过程当中咱们会先生成 exports空对象 ，而后调用 get_builtin_module() 方法去取内建模块，经过执行 register_func 填充空对象，最后按模块名缓存起来并返回给调用方使用。

核心模块引入流程

图片描述

模块调用

至此咱们已经有个大概概念了，梳理一下各类模块之间的关系：

  • C/C++内建模块是最底层核心模块，主要提供API给Javascript核心模块和第三方Javascript模块使用；
  • Javascript核心模块分两类，一类做为C/C++内建模块的封装层和桥接层，一类纯粹的功能模块；
  • 文件模块分Javascript模块和C/C++扩展模块；

ES6模块加载

直到ES6标准化模块功能，统一替代了以前多种模块实现库，成为浏览器和服务器通用的模块解决方案。ES6 模块的设计思想是尽可能的静态化，使得编译时就能肯定模块的依赖关系，以及输入和输出的变量、函数、类。CommonJS 和 AMD 模块，都只能在运行时肯定这些东西。
ES6 的模块有几个须要注意的地方:

  • 自动采用严格模式，即便你没有使用"use strict";
  • 顶层的this指向undefined;
// CommonJS模块
let {readFile} = require('fs');
// ES6模块
import {readFile} from 'fs';

以上为例。
CommonJS加载整个 fs模块 生成一个模块对象，而后从对象中导出 readFile方法 。
ES6 模块经过 import命令 从 fs模块 加载输入的变量、函数、类。
结果就是ES6模块效率高，可是拿不到模块对象自己。

加载方案 加载 输出
CommonJS 运行时加载 拷贝
ES6 模块 编译时输出接口 引用

因为 ES6 模块是编译时加载，使得静态分析成为可能。好比引入宏（macro）和类型检验（type system）这些只能靠静态分析实现的功能。

ES6 模块还有如下好处:

  • 再也不须要UMD模块格式了，未来服务器和浏览器都会支持 ES6 模块格式。目前，经过各类工具库，其实已经作到了这一点。
  • 未来浏览器的新 API 就能用模块格式提供，再也不必须作成全局变量或者 navigator对象 的属性。
  • 再也不须要对象做为命名空间（好比Math对象），将来这些功能能够经过模块提供。
  • ES6模块提供了 export导出命令 和 import导入命令 ，它们一样具备全局提高的效果，只要在顶层使用便可。

export导出命令

支持输出变量、函数、类。

//变量
export var a = 1;
//函数
export function log(n) {
  console.log(n);
}
//类
export class Num {}

我习惯写法是使用对象方式输出，整个模块导出什么一目了然。

//变量
var a = 1;
//函数
function log(n) {
  console.log(n);
}
//类
class Num {}

export {a, log, Num};

这种写法也支持as关键字对外重命名

export {a as b, log as cng, Num as Digit};

这里有一个隐藏比较深的概念性知识，export命令规定的是对外的接口必须与模块内部的变量、函数、类创建一一对应关系。这种写法是OK的。

export var a = 1;
//或者
var a = 1;
export {
    a,
    //或者
    a as b,
}

可是你不能这么写，尽管看起来没什么问题，不过没有提供对外的接口，只是直接或者间接输出1。

export  1;
//或者
var a = 1;
export a

特别容易让人混淆的是这一句，因此要特别注意

//正确
export var a = 1;
//错误
var a = 1;
export a

这不只仅是针对变量，包括函数和类也遵循这种写法，之因此会有这种要求是由于 export语句 输出的接口，与其对应的值是动态绑定关系，即经过该接口，能够取到模块内部实时的值。

export var a = 1
setTimeout(() => a = 2, 3000);
//后续引用a会获得2

import 导入命令

和expor相对应的按需引入写法以下

//直接引入写法
import {a, log, Num} from 'xx';

import也支持使用as关键字

import {a as b, log as cng, Num as Digit} from 'xx';

和 export 动态绑定值不一样，import 是只读静态执行，即你不能修改引用的模块变量、函数、类等，也不能使用表达式和变量这种运行时才能引入静态分析阶段无法获得值的写法。

//修改属性
import{a} from 'xx'
a = 2//error
//表达式引入
import{'l' + 'og'} from 'xx'
//变量引入
var module = 'xx';
import {} from module//error
//判断引入
//error
if (true) {
  import {} from 'xx1';
} else {
  import {} from 'xx2';
}

由于屡次引用也只会执行一次，尽管不推荐，可是这种写法也是能够的

import {a} from 'xx';
import {log} from 'xx';
//等价于
import {a, log} from 'xx';

import也支持这种写法，仅仅执行模块，可是不输入任何变量、函数、类。

import 'xx';

关键字default

export 支持 关键字default 设置默认导出的变量、函数、类:
1， 每一个模块只支持一个关键字default默认导出;
2， 可使用函数名或匿名函数导出，即便指定了函数名也不能在模块外部引用，等同视为匿名函数加载;

//函数
function log(n) {
    console.log(n);
}
export default log;
//或者
export default function(n) {
    console.log(n);
}
//或者
export default function log(n) {
    console.log(n);
}

其余模块加载该模块时，import命令能够为该默认导出函数指定任意名字。

export default function log(n) {
  console.log(n);
}
//加载
import anyName from 'xx';

若是想在一条 import语句 中，同时输入默认函数和其余接口，能够写成下面这样。

import log, {a, Num as Digit} from 'xx';

本质上这也只是一种语法糖，与下面写法等价

export default log;
import log from 'xx';
//==等价==
export { log as default}
import { default as log } from 'xx';

由于default也是变量，因此不能后面再加变量

export default var a = 1;

可是能够直接输出

export default 1;
export default a;

关键字*

用星号（*）指定一个对象，全部输出值都加载在这个对象上面。

import * as all from 'xx';
const {a, log, Num} = all;

export 与 import 的复合写法

这里提供了两种写法，他们之间会有些不一样。

//引入后导出
import {log} from 'xx';
export {log};
//直接导出
export {log} from 'xx';
//或者
export {log as default} from 'xx';

区别在于第二三种是没有导入动做，因此不能在该模块引用对应的变量、函数、类。

须要注意的是下面三种写法ES6目前还不支持。

export * as all from "xx";
export all from "xx";
export log, {a, Digit as Num} from 'xx';

Nodejs 使用问题

import命令 会被 JavaScript引擎静态分析，先于模块内的其余语句执行，而 Nodejs 的 require() 是运行时加载模块，import命令没法取代require的动态加载功能,因此若是在Nodejs 中使用ES6模块语法要注意这一点。

//成功
var fs = require('f'+'s');
//报错
import fs from ('f'+'s');

有一个提案，建议引入 import() 函数，完成动态加载，已经有实现方案了，我没用过就不说了。

参考资料

nodejs 深刻浅出
ES6 标准入门（第3版）

联系我们 沪ICP备13005482号-10