本文从源码出发，梳理一下nodeJS的模块加载机制。

核心模块

  1. function MyModule(id = '') {
  2.     this.id = id;       // 这个id其实就是我们require的路径
  3.     this.path = path.dirname(id);     // path是Node.js内置模块，用它来获取传入参数对应的文件夹路径
  4.     this.exports = {};        // 导出的东西放这里，初始化为空对象
  5.     this.filename = null;     // 模块对应的文件名
  6.     this.loaded = false;      // loaded用来标识当前模块是否已经加载
  7. }

以上是模块加载的核心模块。我们每require一个模块，都会创造一个上面这种模块实例对象。那么我们在执行require的时候，有哪些步骤呢？答案就在_load方法中。

  1. MyModule._cache = Object.create(null);
  3. MyModule._load = function (request) {    
  4.     // step1：获取文件绝对路径以及完整文件名
  5.     const filename = MyModule._resolveFilename(request);
  6.     // step2：检查缓存，如果有缓存直接返回
  7.     const cachedModule = MyModule._cache[filename];
  8.     if (cachedModule !== undefined) {
  9.         return cachedModule.exports;
  10.     }
  11.       // step3：构造模块实例对象，并加载模块
  12.     const module = new MyModule(filename);
  13.     MyModule._cache[filename] = module;
  14.     module.load(filename);
  16.     return module.exports;
  17. }
  19. // require的本质
  20. MyModule.prototype.require = function (id) {
  21.     return MyModule._load(id);
  22. }

可以看到，当我们调用require方法时，我们拿到的实际上是_load方法的返回值，而这个返回值就是实例对象上的exports属性。在_load中，一共有三步。我们接下来会详细的讲解这三步。

step1：获取文件绝对路径以及完整文件名

我们来看_resolveFilename是怎么实现的

  1. MyModule._extensions = Object.create(null);
  3. MyModule._resolveFilename = function (request) {
  4.     const filename = path.resolve(request);   // 获取传入参数对应的绝对路径
  5.     const extname = path.extname(request);    // 获取文件后缀名
  6.     // 如果没有文件后缀名，尝试添加.js和.json
  7.     if (!extname) {
  8.         const exts = Object.keys(MyModule._extensions);
  9.         for (let i = 0; i < exts.length; i++) {
  10.             const currentPath = `${filename}${exts[i]}`;
  11.             // 如果拼接后的文件存在，返回拼接的路径
  12.             if (fs.existsSync(currentPath)) {
  13.                 return currentPath;
  14.             }
  15.         }
  16.     }
  17.     return filename;
  18. }

我们在写require的时候，常常把文件扩展名省略掉了。但是在源码处理当中实际上是又给我们加上了。这个方法实际作用就是得到文件的绝对路径以及完整的文件名，并返回。如果文件扩展名被省略了，则将当前文件名和可支持的文件扩展名拼接，并搜索是否存在。最后返回拼接后的文件名。

step2：检查缓存，如果有缓存直接返回

略

step3：加载模块

这是模块加载的重头戏，先是创建模块实例对象，再把它加入缓存。这没啥好讲的，重点关注load方法。

  1. MyModule.prototype.load = function (filename) {
  2.     // 获取文件后缀名
  3.     const extname = path.extname(filename);
  4.     // 调用后缀名对应的处理函数来处理
  5.     MyModule._extensions[extname](this, filename);
  6.     this.loaded = true;
  7. }
  9. MyModule._extensions['.js'] = function (module, filename) {
  10.     const content = fs.readFileSync(filename, 'utf8');  // 同步读文件
  11.     module._compile(content, filename);
  12. }
  14. MyModule._extensions['.json'] = function (module, filename) {
  15.     const content = fs.readFileSync(filename, 'utf8');
  16.     module.exports = JSON.parse(content);
  17. }

这部分内容比较多，我们按照顺序来讲。
load方法作用是什么？作用就是根据不同类型的文件，执行不同的加载策略。require支持js，json以及node格式的文件加载。本文只讨论js和json的加载。这里，我们再次遇到了MyModule._extensions这个对象。这个对象的key是类型名，value是处理该类型文件的方法。
对于JSON文件，我们读文件拿到内容后，直接使用JSON.parse就可以将读取的文件变为json对象形式。并将处理后的内容赋给module.exports。
而对于js文件，我们的处理要更复杂一些。

js文件的处理

对于js的文件处理，主要集中在_compile这个方法中。

  1. MyModule.wrapper = [
  2.     '(function (exports, require, module, __filename, __dirname) { ',
  3.     '\n});'
  4. ];
  6. MyModule.wrap = function (script) {
  7.     return MyModule.wrapper[0] + script + MyModule.wrapper[1];
  8. };
  10. MyModule.prototype._compile = function (content, filename) {
  11.     const wrapper = MyModule.wrap(content);    // 获取包装后函数体
  12.     // vm是nodejs的虚拟机模块，runInThisContext方法可以接受一个字符串并将它转化为一个函数
  13.     // 返回值就是转化后的函数，所以compiledWrapper是一个函数
  14.     const compiledWrapper = vm.runInThisContext(wrapper, {
  15.         filename,
  16.         lineOffset: 0,
  17.         displayErrors: true,
  18.     });
  19.     // 准备exports, require, module, __filename, __dirname这几个参数
  20.     // exports可以直接用module.exports，即this.exports
  21.     // require官方源码中还包装了一层，其实我们这里可以直接使用this.require
  22.     // module不用说，就是this了
  23.     // __filename直接用传进来的filename参数了
  24.     // __dirname需要通过filename获取下
  25.     const dirname = path.dirname(filename);
  26.     compiledWrapper.call(this.exports, this.exports, this.require, this,
  27.         filename, dirname);
  28. }

compile方法第一步就是将之前读取的js文件内容，包裹为一个方法。这样做的好处一是可以通过运行方法的方式执行一遍文件内部代码，从而拿到导出的值。另一个好处就是隔离var这种全局变量，避免全局污染。

包装为方法后，此时还是字符串，要变成可执行的方法体。要么通过eval实现，要么就用vm.runInThisContext实现，这里使用后者实现。之后调用call。执行方法。
关键来了，这里的参数很关键，其中一个就是export参数
此时传进去的export是形参，其地址和module.exports指向相同(因为是引用类型嘛)。但是内部不可将export直接赋值. 如： export = 1这样就会丢失module.exports的引用。

完整代码

  1. const path = require('path');
  2. const vm = require('vm');
  3. const fs = require('fs');
  5. function MyModule(id = '') {
  6.     this.id = id;       // 这个id其实就是我们require的路径
  7.     this.path = path.dirname(id);     // path是Node.js内置模块，用它来获取传入参数对应的文件夹路径
  8.     this.exports = {};        // 导出的东西放这里，初始化为空对象
  9.     this.filename = null;     // 模块对应的文件名
  10.     this.loaded = false;      // loaded用来标识当前模块是否已经加载
  11. }
  13. MyModule._cache = Object.create(null);
  14. MyModule._extensions = Object.create(null);
  16. MyModule._load = function (request) {    // request是我们传入的路劲参数
  17.     const filename = MyModule._resolveFilename(request);
  19.     // 先检查缓存，如果缓存存在且已经加载，直接返回缓存
  20.     const cachedModule = MyModule._cache[filename];
  21.     if (cachedModule !== undefined) {
  22.         return cachedModule.exports;
  23.     }
  25.     // 如果缓存不存在，我们就加载这个模块
  26.     // 加载前先new一个MyModule实例，然后调用实例方法load来加载
  27.     // 加载完成直接返回module.exports
  28.     const module = new MyModule(filename);
  30.     // load之前就将这个模块缓存下来，这样如果有循环引用就会拿到这个缓存，但是这个缓存里面的exports可能还没有或者不完整
  31.     MyModule._cache[filename] = module;
  33.     module.load(filename);
  35.     return module.exports;
  36. }
  38. /**
  39.  * 获取完整文件名(带绝对路径)
  40.  * @param request 文件名
  41.  * @returns {string} 完整文件名(带绝对路径)
  42.  * @private
  43.  */
  44. MyModule._resolveFilename = function (request) {
  45.     const filename = path.resolve(request);   // 获取传入参数对应的绝对路径
  46.     const extname = path.extname(request);    // 获取文件后缀名
  48.     // 如果没有文件后缀名，尝试添加.js和.json
  49.     if (!extname) {
  50.         const exts = Object.keys(MyModule._extensions);
  51.         for (let i = 0; i < exts.length; i++) {
  52.             const currentPath = `${filename}${exts[i]}`;
  54.             // 如果拼接后的文件存在，返回拼接的路径
  55.             if (fs.existsSync(currentPath)) {
  56.                 return currentPath;
  57.             }
  58.         }
  59.     }
  61.     return filename;
  62. }
  64. MyModule.prototype.require = function (id) {
  65.     return MyModule._load(id);
  66. }
  68. MyModule.prototype.load = function (filename) {
  69.     // 获取文件后缀名
  70.     const extname = path.extname(filename);
  72.     // 调用后缀名对应的处理函数来处理
  73.     MyModule._extensions[extname](this, filename);
  75.     this.loaded = true;
  76. }
  78. MyModule._extensions['.js'] = function (module, filename) {
  79.     const content = fs.readFileSync(filename, 'utf8');  // 同步读文件
  80.     module._compile(content, filename);
  81. }
  83. MyModule.wrapper = [
  84.     '(function (exports, require, module, __filename, __dirname) { ',
  85.     '\n});'
  86. ];
  88. MyModule.wrap = function (script) {
  89.     return MyModule.wrapper[0] + script + MyModule.wrapper[1];
  90. };
  92. MyModule.prototype._compile = function (content, filename) {
  93.     const wrapper = MyModule.wrap(content);    // 获取包装后函数体
  95.     // vm是nodejs的虚拟机模块，runInThisContext方法可以接受一个字符串并将它转化为一个函数
  96.     // 返回值就是转化后的函数，所以compiledWrapper是一个函数
  97.     const compiledWrapper = vm.runInThisContext(wrapper, {
  98.         filename,
  99.         lineOffset: 0,
  100.         displayErrors: true,
  101.     });
  103.     // 准备exports, require, module, __filename, __dirname这几个参数
  104.     // exports可以直接用module.exports，即this.exports
  105.     // require官方源码中还包装了一层，其实我们这里可以直接使用this.require
  106.     // module不用说，就是this了
  107.     // __filename直接用传进来的filename参数了
  108.     // __dirname需要通过filename获取下
  109.     const dirname = path.dirname(filename);
  111.     compiledWrapper.call(this.exports, this.exports, this.require, this,
  112.         filename, dirname);
  113. }
  115. MyModule._extensions['.json'] = function (module, filename) {
  116.     const content = fs.readFileSync(filename, 'utf8');
  117.     module.exports = JSON.parse(content);
  118. }
  120. // 起始require，源码没有这个。
  121. function myRequire(id) {
  122.     return MyModule._load(id);
  123. }
  126. const a = myRequire('./a.js');
  127. const add = myRequire('./b.js');
  128. const c = myRequire('./c.js');
  129. const c_copy = myRequire('./c.js');
  130. const d = myRequire('./d.js');
  131. const e = myRequire('./e.json');
  133. console.log(a);
  134. console.log(add(1, 2));
  135. console.log(c);
  136. console.log(c_copy);
  137. console.log(d);

后记

我这里实现的只是简单版的requre，真正的requre的流程如下：

  1. 优先加载内置模块，即使有同名文件，也会优先使用内置模块。
  2. 不是内置模块，先去缓存找。
  3. 缓存没有就去找对应路径的文件。
  4. 不存在对应的文件，就将这个路径作为文件夹加载。
  5. 对应的文件和文件夹都找不到就去node_modules下面找。
  6. 还找不到就报错了。

我只是实现了其中的2 3 而已。