14-手写Node模块系统-Node模块原理分析

模块系统是nodejs的基础，使用频率也很高。在使用nodejs过程中，以下几个关于模块系统的问题是否常常困扰着你：

1. 为什么在模块中有全局的require、module.exports、exports、__dirname、__filename等关键字,它们是从哪来的？
2. 为什么一定要使用module.exports或者exports导出模块信息？
3. module.exports和exports的区别，它们之间的关系是什么？

CommonJS规范

众所周知，nodejs是基于CommonJS规范来实现，CommonJS规范主要有以下几点内容：

1. 每个文件就是一个模块，有自己的作用域。在一个文件里面定义的变量、函数、类，都是私有的，对其他文件不可见。
2. 每个模块内部，module变量代表当前模块。这个变量是一个对象，它的exports属性（即module.exports）是对外的接口。加载某个模块，其实是加载该模块的module.exports属性。
3. require方法用于加载模块

// moduleA.js
let name = "Node";
module.exports.str = name;

// moduleB.js
let multiplyBy2 = require('./moduleA');
let res = multiplyBy2.str;
console.log(res);  // Node

看以上定义内容我们知道，CommonJS规范规定了每个模块内部都有module变量表示当前模块，使用exports导出模块内容以及require导入模块

既然一个文件就是一个模块,
既然想要使用模块必须先通过require()导入模块
所以可以推断出require()的作用其实就是读取文件
所以要想了解Node是如何实现模块的, 必须先了解如何执行读取到的代码

执行从文件中读取代码

我们都知道通过fs模块可以读取文件, 但是读取到的数据要么是二进制,
要么是字符串无论是二进制还是字符串都无法直接执行

但是我们知道如果是字符串, 在JS中是有办法让它执行的---使用eval 或者 new Function;

eval

通过eval执行代码

let str = "console.log('NodeJS模块原理')";
eval(str);

缺点: 存在依赖关系, 字符串可以访问外界数据,不安全

let name = "Node";
let str = "console.log(name)";
eval(str);  // Node

new Function

通过new Function执行代码

let str = "console.log('NodeJS模块原理')";
let fn = new Function(str);
fn();

缺点: 存在依赖关系, 依然可以访问外界数据,不安全

let name = "Node";
let str = "console.log(name)";
let fn = new Function(str);
fn();  // Node

以上两种方法都有着明显的缺陷, 可以访问外部数据, 容易被别人注入代码, 有安全隐患

那么我们有没有方法, 做到既可以读取字符串的数据又比较安全, 答案是有的
NodeJS提供了一个vm-虚拟机模块, 这个模块中有两个方法就可以解决上面的问题

导入模块

const vm = require("vm");

runInThisContext

提供了一个安全的环境给我们执行字符串中的代码, 但是不能访问本地的变量, 可以访问全局的变量(也就是global上的变量)

let name = "Node";
let str = "console.log(name)";
vm.runInThisContext(str);   // name is not defined

global.name = "Node";
let str = "console.log(name)";
vm.runInThisContext(str);   // Node

runInNewContext

提供了一个安全的环境给我们执行字符串中的代码, 但是不能访问本地的变量, 也不能访问全局的变量(也就是global上的变量)

let name = "Node";
let str = "console.log(name)";
vm.runInNewContext(str);   // name is not defined

global.name = "Node";
let str = "console.log(name)";
vm.runInNewContext(str);   // name is not defined

这两个方法都可以执行字符串中的代码, 都不能访问本地变量, 但是runInThisContext可以访问全局变量, runInNewContext却不可以

我们知道了如何安全地执行字符串中的代码后, 接下来我们就可以自己来实现NodeJS的模块系统了, 但是在自己实现之前, 我们先来看一下官方是如何实现的

源码分析

1. 准备工作

在电脑中通过nvm安装低版本的Node.js(6.17.1), 因为新版本的代码中做了很多的优化, 不太利于初学者去阅读。
安装好后切换到这个版本

2.编写自定义模块, 并且引入模块

// 02-a.js
exports.str = "Node";

// 02-b.js
let aMoudle = require("./02-a.js");
console.log(aMoudle);
console.log(aMoudle.str);

3.断点调试

在let aMoudle = require("./02-a.js");这一行代码上打一个断点

1. 进入到官方的require方法中

function require(path) {
  return self.require(path);
}

2. 通过Module对象的静态__load方法加载模块文件

Module.prototype.require = function(path) {
  return Module._load(path, this, /* isMain */ false);
};

3. 通过Module对象的静态_resolveFilename方法, 得到绝对路径并添加后缀名

var filename = Module._resolveFilename(request, parent, isMain);

4. 根据路径判断是否有缓存, 如果没有就创建一个新的Module模块对象并缓存起来

var cachedModule = Module._cache[filename];
if (cachedModule) {
   return cachedModule.exports;
}
var module = new Module(filename, parent);
Module._cache[filename] = module;

function Module(id, parent) {
  this.id = id;
  this.exports = {};
}

5. 利用tryModuleLoad方法加载模块

tryModuleLoad(module, filename);

6.1 取出模块后缀

var extension = path.extname(filename);

6.2 根据不同后缀查找不同方法并执行对应的方法, 加载模块

Module._extensions[extension](this, filename);

6.3 如果是JSON就转换成对象

module.exports = JSON.parse(internalModule.stripBOM(content));

6.4 如果是JS就包裹一个函数

var wrapper = Module.wrap(content);
NativeModule.wrap = function(script) {
    return NativeModule.wrapper[0] + script + NativeModule.wrapper[1];
}
NativeModule.wrapper = [
    '(function (exports, require, module, __filename, __dirname) { ',
    '\n});'
];

6.5 执行包裹函数之后的代码, 拿到执行结果(String -- Function)

var compiledWrapper = vm.runInThisContext(wrapper);

6.6 利用apply执行fn函数, 修改module.exports的值

var args = [this.exports, require, module, filename, dirname];
var result = compiledWrapper.call(this.exports, args);

6.7 返回module.exports

return module.exports;

手写Noe模块

02-a.js

exports.str = "Node";

person.json

{
  "name": "zhangsan",
  "gender": "male",
  "age": "20"
}

module.js

const path = require("path");
const fs = require("fs");
const vm = require("vm");

class MyModule {
    constructor(id){
        this.id = id;   // 保存当前模块的绝对路径
        this.exports = {};
    }
}
MyModule._cache = {};
MyModule._extensions = {
    ".js": function (module) {
        // 1.读取JS代码
        let script = fs.readFileSync(module.id);
        // 2.将JS代码包裹到函数中
        /*
        (function (exports, require, module, __filename, __dirname) { 
            exports.str = "Node";
        });
        * */
        let strScript = MyModule.wrapper[0] + script + MyModule.wrapper[1];
        // 3.将字符串转换成JS代码
        let jsScript = vm.runInThisContext(strScript);
        // 4.执行转换之后的JS代码
        jsScript.call(module.exports, module.exports);
    },
    ".json": function (module) {
        let json = fs.readFileSync(module.id);
        let obj = JSON.parse(json);
        module.exports = obj;
    }
};
MyModule.wrapper = [
    '(function (exports, require, module, __filename, __dirname) { ',
    '\n});'
];

function myRequire(filePath) {
    // 1.将转换的相对路径转换为绝对路径
    let absPath = path.join(__dirname, filePath);
    // 2.尝试从缓存中获取当前的模块
    let cachedModule = MyModule._cache[absPath];
    if (cachedModule){
        return cachedModule.exports;
    } 
    // 3.如果没有缓存就自己创建一个MyModule对象, 并缓存起来
    let module = new MyModule(absPath);
    MyModule._cache[absPath] = module;
    // 4.利用tryModuleLoad方法加载模块
    tryModuleLoad(module);
    // 5.返回模块的exports
    return module.exports;
}
function tryModuleLoad(module){
    // 1.取出模块后缀
    let extName = path.extname(module.id);
    MyModule._extensions[extName](module);
}

let aMoudle = myRequire("./02-a.js");
console.log(aMoudle);

---

高频面试题

1. NodeJS中的this为什么是一个空对象?

因为所有的NodeJS文件在执行的时候都会被包裹到一个函数中, this都被修改为了空的module.exports

(function (exports, require, module, __filename, __dirname) {
    // 我们编写的代码
    // 所以说在这里面拿到的this就是 空的module.exports
});
compiledWrapper.call(module.exports, args);

2. NodeJS中为什么可以直接使用exports, require, module, __filename, __dirname

因为所有的NodeJS文件在执行的时候都会被包裹到一个函数中, 这些属性都被通过参数的形式传递过来了

var args = [module.exports, require, module, filename, dirname];
compiledWrapper.call(this.exports, args);

3. NodeJS中为什么不能直接给exports赋值, 而可以给module.exports赋值

exports = "Node";

假如给exports赋值为"Node"就相当于执行下面的代码

(function (exports, require, module, __filename, __dirname) {
    exports = "Node";
});
jsScript.call(module.exports, module.exports);
return module.exports;

相当于
let exports = module.exports;
改变了exports的指向
exports = "Node";
return module.exports;

所以最后返回的module.exports并没有被修改, 还是一个空对象

4. 通过require导入包时候应该使用var/let还是const?

导入包的目的是使用包而不是修改包, 所以导入包时使用const接收