[NodeJs系列]NodeJs模块机制

注： 1. 本文涉及的nodejs源码如无特别说明则所有基于v10.14.1

若是你对NodeJs系列感兴趣，欢迎关注前端神盾局或笔者微信(w979436427)交流讨论node学习心得

Nodejs 中对模块的实现

本节主要基于NodeJs源码，对其模块的实现作一个简要的概述，若有错漏，望诸君不吝指正。

当咱们使用require引入一个模块的时候，概况起来经历了两个步骤：路径分析和模块载入

路径分析

路径分析其实就是模块查找的过程，由_resolveFilename函数实现。

咱们经过一个例子，展开说明：

const http = require('http');
const moduleA = requie('./parent/moduleA');
复制代码

这个例子中，咱们引入两种不一样类型的模块：核心模块-http和自定义模块moduleA

对于核心模块而言，_resolveFilename会跳过查找步骤，直接返回，交给下一步处理

if (NativeModule.nonInternalExists(request)) {
    // 这里的request 就是模块名称 'http'
    return request;
}
复制代码

而对于自定义模块而言，存在如下几种状况（_findPath）

1. 文件模块
2. 目录模块
3. 从node_modules目录加载
4. 全局目录加载

这些在官方文档中已经阐述的很清楚了，这里就再也不赘述。

若是模块存在，那么_resolveFilename会返回该模块的绝对路径，好比/Users/xxx/Desktop/practice/node/module/parent/moduleA.js。

载入模块

获取到模块地址后，Node就开始着手载入模块。

首先，Node会查看模块是否存在缓存中：

// filename 即模块绝对路径
var cachedModule = Module._cache[filename];
if (cachedModule) {
    updateChildren(parent, cachedModule, true);
    return cachedModule.exports;
}
复制代码

存在则返回对应缓存内容，不存在则进一步判断该模块是不是核心模块：

if (NativeModule.nonInternalExists(filename)) {
    return NativeModule.require(filename);
}
复制代码

若是模块既不存在于缓存中也非核心模块，那么Node会实例化一个全新的模块对象

function Module(id, parent){
  // 一般是模块绝对路径
  this.id = id;
  // 要导出的内容
  this.exports = {};
  // 父级模块
  this.parent = parent;
  this.filename = null;
  // 是否已经加载成功
  this.loaded = false;
  // 子模块
  this.children = [];
}

var module = new Module(filename, parent);
复制代码

然后Node会根据路径尝试载入。

function tryModuleLoad(module, filename) {
  var threw = true;
  try {
    module.load(filename);
    threw = false;
  } finally {
    if (threw) {
      delete Module._cache[filename];
    }
  }
}
复制代码

对于不一样的文件扩展名，其载入方法也有所不一样。

• .js文件(_compile)

经过fs同步读取文件内容后将其包裹在指定函数中：

Module.wrapper = [
  '(function (exports, require, module, __filename, __dirname) { ',
  '\n});'
];
复制代码

调用执行此函数：

compiledWrapper.call(this.exports, this.exports, require, this,
                                  filename, dirname);
复制代码

• .json文件

经过fs同步读取文件内容后,用JSON.parse解析并返回内容

var content = fs.readFileSync(filename, 'utf8');
try {
    module.exports = JSON.parse(stripBOM(content));
} catch (err) {
    err.message = filename + ': ' + err.message;
    throw err;
}
复制代码

• .node

这是用C/C++编写的扩展文件，经过dlopen()方法加载最后编译生成的文件。

return process.dlopen(module, path.toNamespacedPath(filename));
复制代码

• .mjs

这是用于处理ES6模块的扩展文件，是NodeJs在v8.5.0后新增的特性。对于这类扩展名的文件，只能使用ES6模块语法import引入，不然将会报错（启用--experimental-modules的状况下）

throw new ERR_REQUIRE_ESM(filename);
复制代码

若是一切顺利，就会返回附加在exports对象上的内容

return module.exports;
复制代码

模块循环依赖

接下来咱们来探究一下模块循环依赖的问题：模块1依赖模块2，模块2依赖模块1，会发生什么？

这里只探究commonjs的状况

为此，咱们建立了两个文件，module-a.js和module-b.js，并让他们相互引用：

module-a.js

console.log(' 开始加载 A 模块');
exports.a = 2;
require('./module-b.js');
exports.b = 3;
console.log('A 模块加载完毕');
复制代码

module-b.js

console.log(' 开始加载 B 模块');
let moduleA = require('./module-a.js');
console.log(moduleA.a,moduleA.b)
console.log('B 模块加载完毕');
复制代码

运行module-a.js，能够看到控制台输出：

开始加载 A 模块
开始加载 B 模块
2 undefined
B 模块加载完毕
A 模块加载完毕
复制代码

这时由于每一个require都是同步执行的，在module-a彻底加载前须要先加载./module-b，此时对于module-a而言，其exports对象上只附加了属性a，属性b是在./module-b加载完成后才赋值的。

QA

1. 如何删除模块缓存？

能够经过delete require.cache(moduleId)来删除对应模块的缓存，其中moduleId表示的是模块的绝对路径，通常的，若是咱们须要对某些模块进行热更新，可使用此特性，举个例子：

// hot-reload.js
console.log('this is hot reload module');

// index.js
const path = require('path');
const fs = require('fs');
const hotReloadId = path.join(__dirname,'./hot-reload.js');
const watcher = fs.watch(hotReloadId);
watcher.on('change',(eventType,filename)=>{
    if(eventType === 'change'){
        delete require.cache[hotReloadId];
        require(hotReloadId);
    }
});
复制代码

2. Node中可使用ES6 模块吗？

从8.5.0版本开始，NodeJs开始支持原生ES6模块，启用该功能须要两个条件：

1. 全部使用ES6模块的文件扩展名都必须是.mjs
2. 命令行选项--experimental-modules node --experimental-modules index.mjs

node --experimental-modules index.mjs
复制代码

可是截止到NodeJs v10.15.0，ES6模块的支持依旧是实验性的，笔者并不推荐在公司项目中使用

参考

1. nodejs-loader.js
2. 朴灵. 深刻浅出Node.js