文章详情

短信预约-IT技能 免费直播动态提醒

请输入下面的图形验证码

提交验证

短信预约提醒成功

彻底搞懂Node.js中的Require机制

2024-12-03 18:06

关注

 本文你能学到什么

请注意我上面提出的问题,本文学完后看看是否都搞能懂。最好跟着练习一遍手写 require 源码,美滋滋。

什么是 CommonJS

每一个文件就是一个模块,拥有自己独立的作用域,变量,以及方法等,对其他的模块都不可见。CommonJS 规范规定,每个模块内部,module 变量代表当前模块。这个变量是一个对象,它的exports属性(即module.exports)是对外的接口。

模块分类

模块加载

介绍了上面的模块分类,正常应该到介绍不同模块的加载环节,这里不这样,只列出目录。先带你看一遍源码,再手写一下,然后我想你自己总结一下这几种模块的加载区别。

加载 Node.js 原生模块

本文不包括直接调用内建纯C/C++模块,也不推荐这样使用,因为我们正常调用的原生模块都是通过 js封装一层,它们自己再去调用,你想直接调用的 Node.js提供的存C/C++ 内建模块,js 封装的一层也都能做到。那部分内容放在 Node.js与 C++ 那些事的文章中介绍。

require 加载普通文件模块

require 加载 C++ 扩展文件模块

require 加载原理(源码分析与手写)

require 源码解析图

 

画了一个源码导图,可以直接跟着导图学一遍配上文章讲解,效果更佳。(导图太大了上传不清晰,需要找我要吧。)

require 源码并不复杂,这里采用的是边看源码边手写的方式讲解(我们最终实现的require 是简易版本,一些源码提到,但是简易版本不会实现),实现 require 其实就是实现整个 Node.js 的模块加载机制,Node.js 的模块加载机制总结下来一共八步。

网上一些文章只分成了3-4步,我这里做了一下细化,为了彻底搞懂我开篇提到的一些问题。

1. 基础准备阶段

Node.js 模块加载的主流程都在 Module 类中,在源码的https://github.com/nodejs/node/blob/master/lib/internal/modules/cjs/loader.js 中进行了基础 Module 类定义,这个构造函数中的内容主要做一些值的初始化,我们自己对照着实现下,为了和源码有一个区别,本文使用 KoalaModule 命名。

 

  1. function KoalaModule(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.  
  8. KoalaModule._cache = Object.create(null); //创建一个空的缓存对象  
  9. KoalaModule._extensions = Object.create(null); // 创建一个空的扩展点名类型函数对象(后面会知道用来做什么) 

然后在源码中你会找到 require 函数,在 KoalaModule 的原型链上,我们实现下

 

  1. Module.prototype.require = function(id) {  
  2.     return Module._load(id, this,  false);  
  3. }; 

在源码中你会发现又调用了_load函数,找到源码中的 _load 函数,(源码位置:https://github.com/nodejs/node/blob/master/lib/internal/modules/cjs/loader.js#L724)下面的所有步骤都是在这个函数中完成调用和 return的,实现简易版_load函数。

 

  1. KoalaModule._load = function (request) {    // request是我们传入的路劲参数  
  2.   // 2.路径分析并定位到文件  
  3.   const filename = KoalaModule._resolveFilename(request);  
  4.   // 3.判断模块是否加载过(缓存判断)  
  5.   const cachedModule = koalaModule._cache[filename];  
  6.   if (cachedModule !== undefined) {  
  7.     return cachedModule.exports;  
  8.   }  
  9.   // 4. 去加载 node 原生模块中  
  10.       
  11.   // 5. 如果缓存不存在,我们需自行加载模块,new 一个 KoalaModule实例  
  12.   // 加载完成直接返回module.exports  
  13.   const module = new KoalaModule(filename);  
  14.   // 6. load加载之前加入缓存,这也是不会造成循环引用问题的原因,但是循环引用,这个缓存里面的exports可能还没有或者不完整 
  15.   KoalaModule._cache[filename] = module;  
  16.   // 7. module.load 真正的去加载代码  
  17.   module.load(filename);  
  18.   // 8. 返回模块的module.exports   
  19.   return module.exports;  

这个函数的源码中有一些其他逻辑的细节判断,有兴趣的小伙伴再学习下,我提出了核心主干。

2. 路径分析并定位到文件

找到源码中的 _resolveFilename 函数,这个方法是通过用户传入的require参数来解析到真正的文件地址。(源码地址:https://github.com/nodejs/node/blob/master/lib/internal/modules/cjs/loader.js)

这个函数源码中比较复杂,因为 require传递过来的值需要一层一层的判断,同时支持多种参数:内置模块,相对路径,绝对路径,文件夹和第三方模块等等,如果是文件夹或者第三方模块还要解析里面的 package.json 和 index.js。这里简单处理,只实现通过相对路径和绝对路径来查找文件,并支持判断文件js和json后缀名判断:

 

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

3. 判断模块是否加载过(缓存判断)

判断这个找到的模块文件是否缓存过,如果缓存过,直接返回 cachedModule.exports, 这里就会想到一个问题为什么在 Node.js 中模块重复引用也不会又性能问题,因为做了缓存。(源码位置:https://github.com/nodejs/node/blob/master/lib/internal/modules/cjs/loader.js)

 

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

4. 去加载 node 原生模块

如果没有进行缓存过,会调用一个加载原生模块的函数,这里分析一下。

注意:第四部分代码我们没有进行手写实现,在_load中进行了注释,但是这里进行了一遍分析,我们写的代码是如何调用到原生模块,本部分涉及到你可能会不想看的C内容,其实也可以忽略掉,过一遍就能知道最后的结论为什么是那样了,不然看了书记不住为什么这样。

比如我们require(net),走完前面的缓存判断就会到达这个loadNativeModule函数(源码位置:https://github.com/nodejs/node/blob/802c98d65de40f245781f591a0b3b38336d1af94/lib/internal/modules/cjs/helpers.js)

 

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

继续往下看 loadNativeModule 函数的调用。

 

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

mod 是一个 NativeModule 对象,这个对象很常见,在 node启动一个文件时候也会用到(源码位置:https://github.com/nodejs/node/blob/802c98d65de40f245781f591a0b3b38336d1af94/lib/internal/bootstrap/loaders.js)

然后到了 mod 的核心函数mod.compileForPublicLoader();,下面这段代码相对源码删除了一些非核心部分。

 

  1. compileForPublicLoader() {    
  2.     this.compileForInternalLoader();    
  3.     return this.exports;    
  4. }    
  5. compileForInternalLoader() {   
  6.     if (this.loaded || this.loading) {  
  7.        return this.exports;    
  8.     }    
  9.     // id就是我们要加载的模块,比如net   
  10.     const id = this.id;    
  11.     this.loading = true;     
  12.     try {    
  13.       const fn = compileFunction(id);    
  14.       fn(this.exports, nativeModuleRequire, this, process, internalBinding, primordials);    
  15.       this.loaded = true;    
  16.     } finally {    
  17.       this.loading = false;    
  18.     }    
  19.     return this.exports;    
  20.   }   

我们重点看compileFunction这里的逻辑。该函数是node_native_module_env.cc模块导出的函数。具体的代码就不贴了,通过层层查找,最后到 node_native_module.cc 的NativeModuleLoader::CompileAsModule。

 

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

我们继续看LookupAndCompile。

 

  1. MaybeLocal<Function> NativeModuleLoader::LookupAndCompile(    
  2.     Local<Context> context,    
  3.     const char* id,    
  4.     std::vector<Local<String>>* parameters,    
  5.     NativeModuleLoader::Result* result) {     
  6.   Isolate* isolate = context->GetIsolate();  
  7.    EscapableHandleScope scope(isolate);   
  8.    Local<String> source;    
  9.   // 找到原生js模块的地址    
  10.   if (!LoadBuiltinModuleSource(isolate, id).ToLocal(&source)) {    
  11.     return {};    
  12.   }    
  13.   // ‘net’ + ‘.js’  
  14.   std::string filename_s = id + std::string(".js");    
  15.   Local<String> filename =    
  16.       OneByteString(isolate, filename_s.c_str(), filename_s.size());    
  17.   // 省略一些参数处理    
  18.   // 脚本源码    
  19.   ScriptCompiler::Source script_source(source, origin, cached_data);    
  20.   // 编译出一个函数    
  21.   MaybeLocal<Function> maybe_fun =   
  22.       ScriptCompiler::CompileFunctionInContext(context,    
  23.                                                &script_source,  
  24.                                                 parameters->size(),  
  25.                                                 parameters->data(),  
  26.                                                 0,    
  27.                                                nullptr,    
  28.                                                options);    
  29.     Local<Function> fun = maybe_fun.ToLocalChecked();    
  30.   return scope.Escape(fun);    
  31. }   

LookupAndCompile 函数首先找到加载模块的源码,然后编译出一个函数。我们看一下LoadBuiltinModuleSource 如何查找模块源码的。

 

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

这里是 id 是 net,通过该 id 从 _source 中找到对应的数据,那么_source 是什么呢?Nodejs 为了提高效率,把原生 js 模块的源码字符串直接转成 ascii 码存到**内存**里。这样加载这些模块的时候,就不需要硬盘 io 了。直接从内存读取就行。_source 的定义(在 node_javascript.cc里,负责编译nodejs 源码或者执行 js2c.py 生成)。

结论:Node.js 在启动时候直接从内存中读取内容,我们通过 require 加载 net 原生模块时,通过 NativeModule的compileForInternalLoader,最终会在 _source 中找到对应的源码字符串,然后编译成一个函数,然后去执行这个函数,执行函数的时候传递 nativeModuleRequire和internalBinding两个函数,nativeModuleRequire用于加载原生 js 模块,internalBinding用于加载纯C++ 编写的内置模块。

 

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

5. 创建一个 KoalaModule 实例

如果不是原生 node 模块,就会当作普通文件模块加载,自己创建一个 KoalaModule 实例,去完成加载。

 

  1. const module = new KoalaModule(filename); 

6. 添加缓存

我把这一小步骤单独提出的原因,想说明的是先进行缓存的添加,然后进行的模块代码的加载,这样就会出现下面的结论,Node.js 官网也有单独介绍,可以自己试一下。

  1.  main 加载a,a 在真正加载前先去缓存中占一个位置
  2.  a 在正式加载时加载了 b
  3.  b 又去加载了 a,这时候缓存中已经有 a 了,所以直接返回 a.exports,这时候 exports 很有可能是不完整的内容。

7. module.load 真正的去加载代码

不在缓存,不是原生模块,缓存已经添加完,我们通过这个 load 函数去加载文件模块,源码中位置(https://github.com/nodejs/node/blob/master/lib/internal/modules/cjs/loader.js)

源码中,会有一个获取文件扩展名的函数findLongestRegisteredExtension 这个方法的具体内容是有扩展名的取扩展名,没有的都按照 .js 为扩展名处理,在这个之前会判断一下 Module._extesions 支持的扩展名,不是所有都支持。

我们自己实现一下 load 函数。

 

  1. KoalaModule.prototype.load = function (filename) {  
  2.   // 获取文件后缀名(我们忽略掉了findLongestRegisteredExtension函数,有兴趣小伙伴自己实现)  
  3.   const extname = path.extname(filename);  
  4.   // 根据不同的后缀名去进行不同的处理  
  5.   KoalaModule._extensions[extname](this, filename);  
  6.   this.loaded = true 

获取到扩展名之后,根据不通的扩展名去执行不同的扩展名函数,源码中支持的扩展名有.js,.json,.node;

7.1. 加载.js

定位到加载 .js 的源码位置(https://github.com/nodejs/node/blob/master/lib/internal/modules/cjs/loader.js)

我们自己实现一下执行.js代码。

 

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

KoalaModule._extensions 中 _compile 函数的执行。找到对应的源码位置(https://github.com/nodejs/node/blob/master/lib/internal/modules/cjs/loader.js#L1037),源码中这里还使用 proxy,我们进行一下简单实现。

 

  1. KoalaModule.wrapper = [  
  2.   '(function (exports, require, module, __filename, __dirname) { ',  
  3.   '\n});'  
  4. ]; 
  5. KoalaModule.wrap = function (script) {  
  6.   return KoalaModule.wrapper[0] + script + KoalaModule.wrapper[1];  
  7. };  
  8. KoalaModule.prototype._compile = function (content, filename) { 
  9.   const wrapper = KoalaModule.wrap(content);    // 获取包装后函数体  
  10.   // vm是 Node.js 的虚拟机模块,runInThisContext方法可以接受一个字符串并将它转化为一个函数  
  11.   // 返回值就是转化后的函数,compiledWrapper是一个函数  
  12.   const compiledWrapper = vm.runInThisContext(wrapper, {  
  13.     filename,  
  14.     lineOffset: 0,  
  15.     displayErrors: true,  
  16.   });  
  17.   const dirname = path.dirname(filename);  
  18.   // 调用函数,这里一定注意传递进的内容。  
  19.   compiledWrapper.call(this.exports, this.exports, this.require, this,  
  20.     filename, dirname);  

这里注意两个地方

 

  1. '(function (exports, require, module, __filename, __dirname) { ',  
  2.   '\n});' 
  1.  this: compiledWrapper函数是通过 call 调用的,第一个参数就是里面的this,这里我们传入的是 this.exports,也就是 module.exports
  2.  exports: compiledWrapper 函数正式接收的第一个参数是 exports,我们传的也是 this.exports,所以 js 文件里面的 exports 也是对module.exports 的一个引用。
  3.  require: 这个方法我们传的是 this.require,其实就是KoalaModule.prototype.require 函数,也就是 KoalaModule._load。
  4.  module: 我们传入的是 this,也就是当前模块的实例。
  5.  __filename:文件所在的绝对路径。
  6.  __dirname: 文件所在文件夹的绝对路径。

以上两点也是我们能在 JS 模块文件里面直接使用这几个变量的原因。

7.2. 加载 .json

加载 .json 文件比较简单,直接使用 JSONParse就可以,定位到源码位置(https://github.com/nodejs/node/blob/master/lib/internal/modules/cjs/loader.js),注意这里不要忘记异常抛出 我们简单实现下:

 

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

7.3  加载 .node

我们自己实现的 C++ 插件或者第三方 C++ 插件,经过编译后会变为.node 扩展名文件。.node 文件的本质是动态链接库,找到对应源码位置(https://github.com/nodejs/node/blob/master/lib/internal/modules/cjs/loader.js)

 

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

直接调了process.dlopen,该函数在node.js里定义。

 

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

找到process_methods模块对应的是node_process_methods.cc。

 

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

这里也过多分析,放到 Node.js 和 C++ 那些事那篇文章一起讲解。

8. 返回模块的 module.exports

 

  1. return module.exports; 

在模块中的代码可以修改 module.exports 的值,不管是从缓存获取,加载原生模块还是普通文件模块,module.exports 都是最终的导出结果

require 原理理解后的思考

require加载是同步还是异步

这个问题我直接告诉你同步还是异步,你可能过一阵又忘记了,我之前就是这样。看过源码或者手写一遍就知道了,代码中所有文件相关操作都是使用的同步,举几个例子:

 

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

exports和module.exports的区别究竟是什么?

在源码中可以发现,

 

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

require在执行文件时候,传递的两个参数 参数一:this.exports = {}; 参数二:this 而this就是 module 所以 module.exports = {};

所以在一个模块没有做任何代码编写之前 exports === module.exports 都是 {} ,共同指向一个引用

看一张图理解这里更清楚:

但是大多数情况下我们开发时,经常会这样导出

 

  1. exports = {  
  2.     name:'kaola'  

或者这样写

 

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

上面这两种情况就是给 exports 或者 module.exports 重新赋值了,改变了引用地址,两个属性就不再===。

关键点:require一个文件,之前在手写代码时你会发现,最终导出的内容是return module.exports;.所以你对exports的重新赋值不会改变模块的导出内容,只是改变了exports这个变量而已。导出内容永远是module.exports

require 会不会造成循环引用的问题

自行去看源码实现中的第 7 步,应就懂了。

require是怎么来的,为什么可以直接在一个文件中使用require

require 到的文件,在 vm 模块最终执行的时,对代码进行了一层包裹,并且把对应的参数传递进去执行。

包裹后的代码:

 

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

执行时的代码: 

  1. const wrapper = this.wrap(content);    // 获取包装后函数体  
  2.  // vm是nodejs的虚拟机模块,runInThisContext方法可以接受一个字符串并将它转化为一个函数  
  3.  const compiledWrapper = vm.runInThisContext(wrapper, {  
  4.      filename,  
  5.      lineOffset: 0,  
  6.      displayErrors: true,  
  7.  });  
  8.  const dirname = path.dirname(filename);  
  9.  compiledWrapper.call(this.exports, this.exports, this.require, this,  
  10.      filename, dirname); 

在这里小伙伴对 vm 模块有疑问的话可以看我的下一篇文章 冷门 Node.js模块 vm 学习必不可少。

通过代码发现 require 函数实际已经传递到了执行的 module 文件中,所以require 在 module 文件中可以直接调用了,同时也应该明白了为什么那几个变量可以直接获取了 dirname,filename 等。

学习补充

CommonJs 与 ES6Module的区别?

区别 require/exports import/export
出现的时间/地点不同 2009年出生 出自CommonJS 2015年出生 出自ECMAScript2015(ES6)
不同端的使用限制 100 999
加载方式 同步加载,运行时动态加载,加载的是一个对象,对象需要在脚本运行完成后才会生成 异步加载,静态编译,ES6 模块不是对象,它的对外接口只是一种静态定义,在代码静态解析阶段就会生成
输出对比 输出的是一个值的拷贝,一旦输出一个值,模块内部的变化不会影响到这个值 输出的是值的引用,JS 引擎对脚本静态分析的时候,遇到模块加载命令import,就会生成一个只读引用。等到脚本真正执行时,再根据这个只读引用,到被加载的那个模块里面去取值。若文件引用的模块值改变,require 引入的模块值不会改变,而 import 引入的模块值会改变。
使用方式 上面手写过程中已经说了使用方式 import的使用方式

Node.js 中的 vm 模块是什么?

写不动了,喝完奶茶的动力过去了,我要去睡觉了,后面发一篇小文章介绍 vm 模块吧!有兴趣的小伙伴也可以直接去 Node.js 官网学习下。

总结

看源码最好带着一些目的,开篇的一些问题只知道结果并不都知道原因就是我写本文的目的,看源码的过程中也能学到一些内容,比如一些地方你会发现源码是比你写的好,嘿嘿。require 的源码中还是有很多细节点可以学习和分析的,比如这里忽略了 isMain 主文件判断,启动时候 require 的使用(这个会在另一篇文章 Node.js 的启动源码分析中介绍),以及在 load 方法中执行模块文件时候使用到的 proxy,都可以学习下,本文是一个思路,下篇见。

 

 

来源:前端大全内容投诉

免责声明:

① 本站未注明“稿件来源”的信息均来自网络整理。其文字、图片和音视频稿件的所属权归原作者所有。本站收集整理出于非商业性的教育和科研之目的,并不意味着本站赞同其观点或证实其内容的真实性。仅作为临时的测试数据,供内部测试之用。本站并未授权任何人以任何方式主动获取本站任何信息。

② 本站未注明“稿件来源”的临时测试数据将在测试完成后最终做删除处理。有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

软考中级精品资料免费领

  • 历年真题答案解析
  • 备考技巧名师总结
  • 高频考点精准押题
  • 2024年上半年信息系统项目管理师第二批次真题及答案解析(完整版)

    难度     813人已做
    查看
  • 【考后总结】2024年5月26日信息系统项目管理师第2批次考情分析

    难度     354人已做
    查看
  • 【考后总结】2024年5月25日信息系统项目管理师第1批次考情分析

    难度     318人已做
    查看
  • 2024年上半年软考高项第一、二批次真题考点汇总(完整版)

    难度     435人已做
    查看
  • 2024年上半年系统架构设计师考试综合知识真题

    难度     224人已做
    查看

相关文章

发现更多好内容

猜你喜欢

AI推送时光机
位置:首页-资讯-后端开发
咦!没有更多了?去看看其它编程学习网 内容吧
首页课程
资料下载
问答资讯