美文网首页
14-手写Node模块系统-Node模块原理分析

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

作者: 仰望_IT | 来源:发表于2020-03-31 11:29 被阅读0次

    模块系统是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);
    }
    
    1. 通过Module对象的静态__load方法加载模块文件
    Module.prototype.require = function(path) {
      return Module._load(path, this, /* isMain */ false);
    };
    
    1. 通过Module对象的静态_resolveFilename方法, 得到绝对路径并添加后缀名
    var filename = Module._resolveFilename(request, parent, isMain);
    
    1. 根据路径判断是否有缓存, 如果没有就创建一个新的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 = {};
    }
    
    1. 利用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接收

    相关文章

      网友评论

          本文标题:14-手写Node模块系统-Node模块原理分析

          本文链接:https://www.haomeiwen.com/subject/dzpmuhtx.html