使用

  1. // 导出模块, 可以导出任意的数据类型
  2. module.exports = "hello world"
  4. // 或者使用
  5. exports.a = "test"
  7. // 引入模块
  8. const index = require('./index');
  • 一个模块真正导出的是 module.exports 的值，exports只是 module.exports 的一个引用。通过exports.XXX来修改module.exports.XXX ```javascript // 默认 module.exports 的值为{}，exports 也指向这个空对象

// 同时存在 module.exports，再改变对象的指向，exports就没有意义了

// 只能使用 exports.xxx 导出才有效 exports.a = ‘hello world’;

// 引用修改了，导出无效 exports = “hello world”

// 源码在传入函数参数时：exports = module.exports

  2. - require 命令用于加载模块文件。**require命令的基本功能是，读入并执行一个JavaScript文件，然后返回该模块的exports对象。如果没有发现指定模块，会报错**。
  3. - require 值会缓存，导入过则会通过深拷贝的方式存在内存中。
  4. - requrie 运行时加载是整个模块(对象)
  5. <a name="TFiXg"></a>
  6. # 原理实现
  7. 使用fs、vm、path内置模块，以函数包裹形式实现，把字符串变成可执行函数。
  8. ```javascript
  9. const vm = require("vm")
  10. const path = require("path")
  11. const fs = require("fs")
  13. /**
  14.  * commonjs的require函数：引入module
  15.  * @param {string} filename module的名称
  16.  */
  17. function customRequire(filename){
  18.     const pathToFile = path.resolve(__dirname, filename)
  19.     const content = fs.readFileSync(pathToFile, 'utf-8')
  20.     // 使用函数包裹模块，执行函数
  21.     // 注入形参（全局dioxide）：require、module、exports、__dirname、__filename
  22.     const wrapper = [
  23.         '(function(require, module, exports, __dirname, __filename){',
  24.         '})'
  25.     ]
  26.     const wrappedContent = wrapper[0] + content + wrapper[1]
  27.     const script = new vm.Script(wrappedContent, {
  28.         filename: 'index.js'
  29.     })
  30.     const module = {
  31.         exports: {}
  32.     }
  33.     //转换为函数，类似eval，(funcion(require, module, exports){ xxx })
  34.     const result = script.runInThisContext();
  35.     // 函数执行，引入模块，若内部有require继续递归
  36.     // exports为module.exports的引用
  37.     result(customRequire, module, module.exports);
  38.     return module.exports
  39. }
  41. global.customRequire = customRequire

总结：

  • 读取文件为字符串，包裹为一个函数字符串
  • 放到 vm 里去执行变为函数（类似new Function）
  • 执行函数，传入 require，module，exports 等参数

源码

路径：/lib/internal/modules/cjs/

  1. //require函数定义
  2. 1、Module.prototype.require：调用__load函数
  3. 2、Module.__load：_cache处理，调用load函数
  4. 3、Module.prototype.load函数：调用Module._extensions[extension](this, filename);
  5. //不同的后缀通过定义不同的函数指定解析规则：以Module._extensions['.js']为例
  6. 4、Module._extensions['.js'] = function(module, filename) {
  7.   //读取缓存或者通过readFileSync读取内容
  8.   if (cached?.source) {
  9.     content = cached.source;
  10.     cached.source = undefined;
  11.   } else {
  12.     content = fs.readFileSync(filename, 'utf8');
  13.   }
  14.   //...
  15.   //调用compile解析
  16.   module._compile(content, filename);
  17. }
  18. 5、Module.prototype._compile = function(content, filename){
  19.   //生成包裹函数：warpSafe获取函数字符串并使用vm执行生成执行函数
  20.   const compiledWrapper = wrapSafe(filename, content, this);
  21.   //执行函数
  22.   const exports = this.exports;
  23.   const thisValue = exports;
  24.   const module = this;
  25.   if (inspectorWrapper) {
  26.     result = inspectorWrapper(compiledWrapper, thisValue, exports,
  27.                               require, module, filename, dirname);
  28.   } else {
  29.     //静态方法Reflect.apply(target, thisArgument, argumentsList)
  30.     //通过指定的参数列表发起对目标(target)函数的调用
  31.     result = ReflectApply(compiledWrapper, thisValue,
  32.                           [exports, require, module, filename, dirname]);
  33.   }
  34.   return result;
  35. }
  36. 6、function wrapSafe(filename, content, cjsModuleInstance) {
  37.     /* 生成包裹函数字符：
  38.     let wrap = function(script) {
  39.        return Module.wrapper[0] + script + Module.wrapper[1];
  40.     };
  41.     const wrapper = [
  42.       '(function (exports, require, module, __filename, __dirname) { ',
  43.       '\n});',
  44.     ]；*/
  45.       const wrapper = Module.wrap(content);
  46.     //获取包裹函数
  47.     return vm.runInThisContext(wrapper, {
  48.       filename,
  49.       lineOffset: 0,
  50.       displayErrors: true,
  51.       importModuleDynamically: async (specifier) => {
  52.         const loader = asyncESM.ESMLoader;
  53.         return loader.import(specifier, normalizeReferrerURL(filename));
  54.       },
  55.     });
  56. }
  • 后缀名扩展解析，策略模式 ```javascript const Module = require(‘module’) // 后缀解析扩展：.test后缀同.js后缀 Module._extensions[‘.test’] = Module._extensions[‘.js’]

// 切面编程，覆盖 js 的处理策略 const prevFunc = Module._extensions[‘.js’] Module._extensions[‘.js’] = function(…args){ console.log(‘load script’) prevFunc.apply(prevFunc, args) } ```