重写require方法

首先，我们总结下commonjs模块化的特点：

• 每个模块有自己的作用域
• js文件作为模块导出的化，默认能使用两个参数：module和exports，它们的关系可以看作

const module = { ...xxx , exports : { } }
let { exports } = module 

此时当前作用域包含module和exports两个对象，且exports 的引用可以更改。但我们知道：最终模块取得是module.exports引用，所以此处exports仅仅是为了方便添加属性，如

exports.a = 'a'  //代替了 module.exports.a = 'a'

• 模块可以多次加载，但是只会在第一次加载时运行一次，由此可知，使用了缓存

于是，我们按实际情况思考流程：

    1.node执行入口文件index.js
    2.入口文件require了其他js文件
    3.此时node fs模块找到该文件，找不到则报错
    猜测：
    4.读取文件代码
    5.在当前作用于下定义module实例，eval执行该函数后module实例会被填充内容
    6.将module缓存起来，以后require时优先从缓存中取。（可以放在require函数的静态属性中）

编码如下

module1文件

const a = 10;

const func = () => {
  return a * 5;
};

module.exports = {
  a,
  func,
};

index.js文件

const { join } = require("path")
const fs = require("fs")

const myRequire = function (path) {
    // 获取当前文件的项目路径或绝对路径
    const targetPath = join(__dirname, path)
    // 尝试从缓存中取
    if (arguments.callee.modulesCache[targetPath])
        return arguments.callee.modulesCache[targetPath];

    const code = fs.readFileSync(targetPath, "utf-8");
    //创建module实例，暴露module和exports给模块
    let module = { exports: {} };
    let { exports } = module;

    //执行文件代码，将模块内容执行，此时module已包含模块内容
    eval(code);

    //缓存该模块
    arguments.callee.modulesCache[targetPath] = module.exports;
    return module.exports;
};

myRequire.modulesCache = {};

const module1 = myRequire("./module1.js");
// const module2 = myRequire("./module2.js"); //报错
console.log(module1); // { a: 10, func: [Function: func] }
// console.log(module2);

此处测试案例只引入了一个文件，后续测试中再引入文件中继续引入依然成功，且正常使用缓存
总结：

• 实现模块间引用主要依赖于
  1.文件读取
  2.执行js代码字符串（常见方式是eval 或者 new Function）
• 由于其只是读取文件、执行代码，所以是执行时加载，故可以动态的进行加载

const isExist = db.search();
if (isExist) {
  const { clearData } = myRequire("./someModule.js");
}
// 此时，我们只能通过数据库返回结果来判断是否引入 clearData 方法

• commonjs会读取整个文件，并以对象的形式取出部分内容，对不需要取出的内容会有内存浪费
• 目前nodejs偏向于使用esm引入模块，并作为未来的标准，其特点是编译时加载，即在js引擎编译解析js文件时，其依赖内容已经在内存中初始化完毕，并返回其引用地址，详情可参考 https://es6.ruanyifeng.com/#docs/module-loader