彻底搞懂 Node.js 中的 Require 机制(源码分析到手写实践)

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

KoalaModule._cache = Object.create(null); //创建一个空的缓存对象
KoalaModule._extensions = Object.create(null); // 创建一个空的扩展点名类型函数对象(后面会知道用来做什么)

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

KoalaModule._load = function (request) {    // request是我们传入的路劲参数
  // 2.路径分析并定位到文件
  const filename = KoalaModule._resolveFilename(request);

  // 3.判断模块是否加载过(缓存判断)
  const cachedModule = koalaModule._cache[filename];
  if (cachedModule !== undefined) {
    return cachedModule.exports;
  }
  // 4. 去加载 node 原生模块中
  /*const mod = loadNativeModule(filename, request);
   if (mod && mod.canBeRequiredByUsers) return mod.exports;*/
   
  // 5. 如果缓存不存在，我们需自行加载模块，new 一个 KoalaModule实例
  // 加载完成直接返回module.exports
  const module = new KoalaModule(filename);

  // 6. load加载之前加入缓存，这也是不会造成循环引用问题的原因，但是循环引用，这个缓存里面的exports可能还没有或者不完整
  KoalaModule._cache[filename] = module;
  // 7. module.load 真正的去加载代码
  module.load(filename);
  // 8. 返回模块的module.exports 
  return module.exports;
}

KoalaModule._resolveFilename = function (request) {
  const filename = path.resolve(request);   // 获取传入参数对应的绝对路径
  const extname = path.extname(request);    // 获取文件后缀名
  // 如果没有文件后缀名，判断是否可以添加.js和.json
  if (!extname) {
    const exts = Object.keys(KoalaModule._extensions);
    for (let i = 0; i < exts.length; i++) {
      const currentPath = `${filename}${exts[i]}`;

      // 如果拼接后的文件存在，返回拼接的路径
      if (fs.existsSync(currentPath)) {
        return currentPath;
      }
    }
  }
  return filename;
}

  const cachedModule = koalaModule._cache[filename];
  if (cachedModule !== undefined) {
    return cachedModule.exports;
  }

const mod = loadNativeModule(filename, request);
  if (mod && mod.canBeRequiredByUsers) return mod.exports;

function loadNativeModule(filename, request) {
 // 这里判断下是不是在原生js模块中  ，NativeModule在bootstrap/loader.js中定义
  const mod = NativeModule.map.get(filename);
  if (mod) {
    debug('load native module %s', request);
    mod.compileForPublicLoader();
    return mod;
  }
}

compileForPublicLoader() {  
    this.compileForInternalLoader();  
    return this.exports;  
}  
  
compileForInternalLoader() {  
    if (this.loaded || this.loading) {  
      return this.exports;  
    }  
    // id就是我们要加载的模块，比如net 
    const id = this.id;  
    this.loading = true;  
  
    try {  
      const fn = compileFunction(id);  
      fn(this.exports, nativeModuleRequire, this, process, internalBinding, primordials);  
      this.loaded = true;  
    } finally {  
      this.loading = false;  
    }  
    return this.exports;  
  }  

MaybeLocal<Function> NativeModuleLoader::CompileAsModule(  
    Local<Context> context,  
    const char* id,  
    NativeModuleLoader::Result* result) {  
5.  
6.  Isolate* isolate = context->GetIsolate();  
7.  // 函数的形参  
8.  std::vector<Local<String>> parameters = {  
9.      FIXED_ONE_BYTE_STRING(isolate, "exports"),  
10.      FIXED_ONE_BYTE_STRING(isolate, "require"),  
11.      FIXED_ONE_BYTE_STRING(isolate, "module"),  
12.      FIXED_ONE_BYTE_STRING(isolate, "process"),  
13.      FIXED_ONE_BYTE_STRING(isolate, "internalBinding"),  
14.      FIXED_ONE_BYTE_STRING(isolate, "primordials")};  
15.  // 编译出一个函数  
16.  return LookupAndCompile(context, id, ¶meters, result);  
17.}

MaybeLocal<Function> NativeModuleLoader::LookupAndCompile(  
    Local<Context> context,  
    const char* id,  
    std::vector<Local<String>>* parameters,  
    NativeModuleLoader::Result* result) {  
  
  Isolate* isolate = context->GetIsolate();  
  EscapableHandleScope scope(isolate);  
  
  Local<String> source;  
  // 找到原生js模块的地址  
  if (!LoadBuiltinModuleSource(isolate, id).ToLocal(&source)) {  
    return {};  
  }  
  // ‘net’ + ‘.js’
  std::string filename_s = id + std::string(".js");  
  Local<String> filename =  
      OneByteString(isolate, filename_s.c_str(), filename_s.size());  
  // 省略一些参数处理  
  // 脚本源码  
  ScriptCompiler::Source script_source(source, origin, cached_data);  
  // 编译出一个函数  
  MaybeLocal<Function> maybe_fun =  
      ScriptCompiler::CompileFunctionInContext(context,  
                                               &script_source,  
                                               parameters->size(),  
                                               parameters->data(),  
                                               0,  
                                               nullptr,  
                                               options);  
    Local<Function> fun = maybe_fun.ToLocalChecked();  
  return scope.Escape(fun);  
}  

MaybeLocal<String> NativeModuleLoader::LoadBuiltinModuleSource(Isolate* isolate, const char* id) {  
  const auto source_it = source_.find(id);  
  return source_it->second.ToStringChecked(isolate);  
}  

const fn = compileFunction(id);  
fn(this.exports, nativeModuleRequire, this, process, internalBinding, primordials);  

  const module = new KoalaModule(filename);

KoalaModule.prototype.load = function (filename) {
  // 获取文件后缀名(我们忽略掉了findLongestRegisteredExtension函数，有兴趣小伙伴自己实现)
  const extname = path.extname(filename);

  // 根据不同的后缀名去进行不同的处理
  KoalaModule._extensions[extname](this, filename);

  this.loaded = true;
}

KoalaModule._extensions['.js'] = function (module, filename) {
  const content = fs.readFileSync(filename, 'utf8');
  module._compile(content, filename);
}

KoalaModule.wrapper = [
  '(function (exports, require, module, __filename, __dirname) { ',
  '\n});'
];

KoalaModule.wrap = function (script) {
  return KoalaModule.wrapper[0] + script + KoalaModule.wrapper[1];
};

KoalaModule.prototype._compile = function (content, filename) {
  const wrapper = KoalaModule.wrap(content);    // 获取包装后函数体

  // vm是 Node.js 的虚拟机模块，runInThisContext方法可以接受一个字符串并将它转化为一个函数
  // 返回值就是转化后的函数，compiledWrapper是一个函数
  const compiledWrapper = vm.runInThisContext(wrapper, {
    filename,
    lineOffset: 0,
    displayErrors: true,
  });
  const dirname = path.dirname(filename);
  // 调用函数，这里一定注意传递进的内容。
  compiledWrapper.call(this.exports, this.exports, this.require, this,
    filename, dirname);
}

'(function (exports, require, module, __filename, __dirname) { ',
  '\n});'

KoalaModule._extensions['.json'] = function (module, filename) {
  const content = fs.readFileSync(filename, 'utf8');
   try {
   module.exports = JSONParse(content);
  } catch (err) {
    throw err;
  }
}

Module._extensions['.node'] = function(module, filename) {  
  // ...  
  //return process.dlopen(module, path.toNamespacedPath(filename)); 
};  

const rawMethods = internalBinding('process_methods');  
process.dlopen = rawMethods.dlopen;  

env->SetMethod(target, "dlopen", binding::DLOpen);

return module.exports;

fs.existsSync(currentPath)
fs.readFileSync(filename, 'utf8');

compiledWrapper.call(this.exports, this.exports, this.require, this,
    filename, dirname);

exports = {
    name:'kaola'
}

module.export = {
    value:'程序员成长指北‘
}

`(function (exports, require, module, __filename, __dirname) { ${script} \n});`

    const wrapper = this.wrap(content);    // 获取包装后函数体
    // vm是nodejs的虚拟机模块，runInThisContext方法可以接受一个字符串并将它转化为一个函数
    const compiledWrapper = vm.runInThisContext(wrapper, {
        filename,
        lineOffset: 0,
        displayErrors: true,
    });

    const dirname = path.dirname(filename);
    
    compiledWrapper.call(this.exports, this.exports, this.require, this,
        filename, dirname);

❤️爱心三连击
1.看到这里了就点个在看支持下吧，你的「点赞，在看」是我创作的动力。
2.关注公众号程序员成长指北，回复「1」加入Node进阶交流群！「在这里有好多 Node 开发者，会讨论 Node 知识，互相学习」！
3.也可添加微信【ikoala520】，一起成长。