聊聊Node.js的模块机制

本文转载自微信公众号「编程杂技」，作者theanarkh。转载本文请联系编程杂技公众号。

创新互联公司是一家专注于成都做网站、成都网站建设与策划设计,沂南网站建设哪家好?创新互联公司做网站,专注于网站建设10年,网设计领域的专业建站公司;建站业务涵盖:沂南等地区。沂南做网站价格咨询:18980820575

前言：模块机制是 Node.js 中非常重要的组成，模块机制使得我们可以以模块化的方式写代码，而不是全部代码都写到一个文件里。我们平时使用的比较多的通过 require 加载模块，但是我们可能不是很清楚 require 的实现原理，另外 Node.js 里存在多种模块类型，加载原理也不太一样，本文将会介绍 Node.js 模块机制以及实现原理。

1 模块机制的初始化和使用

1.1 注册 C++ 模块

在 Node.js 启动的时候，会通过 RegisterBuiltinModules 注册 C++ 模块。

 
 
 
 
    
  
  
  
  
  1. void RegisterBuiltinModules() {  
    2. 
  
  
  
  
  2.  #define V(modname) _register_##modname();  
    3. 
  
  
  
  
  3.    NODE_BUILTIN_MODULES(V)  
    4. 
  
  
  
  
  4.  #undef V  
    5. 
  
  
  
  
  5. }
    6.

NODE_BUILTIN_MODULES是一个C语言宏，宏展开后如下(省略类似逻辑)

 
 
 
 
    
  
  
  
  
  1. voidRegisterBuiltinModules() {  
    2. 
  
  
  
  
  2.     #define V(modname) _register_##modname();  
    3. 
  
  
  
  
  3.       V(tcp_wrap)   
    4. 
  
  
  
  
  4.       V(timers)  
    5. 
  
  
  
  
  5.       ...其它模块  
    6. 
  
  
  
  
  6.     #undef V  
    7. 
  
  
  
  
  7. }
    8.

再一步展开如下

 
 
 
 
    
  
  
  
  
  1. void RegisterBuiltinModules() {  
    2. 
  
  
  
  
  2.   _register_tcp_wrap();  
    3. 
  
  
  
  
  3.   _register_timers();  
    4. 
  
  
  
  
  4. }
    5.

执行了一系列_register开头的函数，但是我们在Node.js源码里找不到这些函数，因为这些函数是在每个C++模块定义的文件里(.cc文件的最后一行)通过宏定义的。以tcp_wrap模块为例，看看它是怎么做的。文件tcp_wrap.cc的最后一句代码 NODE_MODULE_CONTEXT_AWARE_INTERNAL(tcp_wrap, node::TCPWrap::Initialize) 宏展开是

 
 
 
 
    
  
  
  
  
  1. #define NODE_MODULE_CONTEXT_AWARE_INTERNAL(modname, regfunc)  \  
    2. 
  
  
  
  
  2.     NODE_MODULE_CONTEXT_AWARE_CPP(modname, 
    3. 
  
  
  
  
  3.                                   regfunc, 
    4. 
  
  
  
  
  4.                                   nullptr, 
    5. 
  
  
  
  
  5.                                   NM_F_INTERNAL)
    6.

继续展开

 
 
 
 
    
  
  
  
  
  1. define NODE_MODULE_CONTEXT_AWARE_CPP(modname, regfunc, priv, flags) \  
    2. 
  
  
  
  
  2.   static node::node_module _module = {              \  
    3. 
  
  
  
  
  3.       NODE_MODULE_VERSION,                        \  
    4. 
  
  
  
  
  4.       flags,                        \  
    5. 
  
  
  
  
  5.       nullptr,                        \  
    6. 
  
  
  
  
  6.       __FILE__,                        \  
    7. 
  
  
  
  
  7.       nullptr,                        \  
    8. 
  
  
  
  
  8.       (node::addon_context_register_func)(regfunc),  \  
    9. 
  
  
  
  
  9.       NODE_STRINGIFY(modname),                        \  
    10. 
  
  
  
  
  10.       priv,                        \  
    11. 
  
  
  
  
  11.       nullptr};                        \  
    12. 
  
  
  
  
  12.   void _register_tcp_wrap() { node_module_register(&_module); }
    13.

我们看到每个C++模块底层都定义了一个 _register 开头的函数，在 Node.js 启动时，就会把这些函数逐个执行一遍。我们继续看一下这些函数都做了什么，在这之前，我们要先了解一下Node.js中表示 C++ 模块的数据结构。

 
 
 
 
    
  
  
  
  
  1. struct node_module {  
    2. 
  
  
  
  
  2.   int nm_version;  
    3. 
  
  
  
  
  3.   unsigned int nm_flags;  
    4. 
  
  
  
  
  4.   void* nm_dso_handle;  
    5. 
  
  
  
  
  5.   const char* nm_filename;  
    6. 
  
  
  
  
  6.   node::addon_register_func nm_register_func;  
    7. 
  
  
  
  
  7.   node::addon_context_register_func nm_context_register_func;  
    8. 
  
  
  
  
  8.   const char* nm_modname;  
    9. 
  
  
  
  
  9.   void* nm_priv;  
    10. 
  
  
  
  
  10.   struct node_module* nm_link;  
    11. 
  
  
  
  
  11. };
    12.

我们看到 _register 开头的函数调了 node_module_register，并传入一个 node_module 数据结构，所以我们看一下node_module_register 的实现

 
 
 
 
    
  
  
  
  
  1. void node_module_register(void* m) {  
    2. 
  
  
  
  
  2.       struct node_module* mp = reinterpret_cast(m);  
    3. 
  
  
  
  
  3.       if (mp->nm_flags & NM_F_INTERNAL) {  
    4. 
  
  
  
  
  4.         mp->nm_link = modlist_internal;  
    5. 
  
  
  
  
  5.         modlist_internal = mp;  
    6. 
  
  
  
  
  6.       } else if (!node_is_initialized) { 
    7. 
  
  
  
  
  7.         mp->nm_flags = NM_F_LINKED;  
    8. 
  
  
  
  
  8.         mp->nm_link = modlist_linked;  
    9. 
  
  
  
  
  9.         modlist_linked = mp;  
    10. 
  
  
  
  
  10.       } else {  
    11. 
  
  
  
  
  11.         thread_local_modpending = mp;  
    12. 
  
  
  
  
  12.       }  
    13. 
  
  
  
  
  13. }
    14.

C++ 内置模块的 flag 是 NM_F_INTERNAL，所以会执行第一个if的逻辑，modlist_internal 类似一个头指针。if 里的逻辑就是头插法建立一个单链表。

1.2 初始化模块加载器

注册完 C++ 模块后，接着初始化模块加载器。

 
 
 
 
    
  
  
  
  
  1. MaybeLocal Environment::BootstrapInternalLoaders() {
    2. 
  
  
  
  
  2.   EscapableHandleScope scope(isolate_);
    3. 
  
  
  
  
  3. 
  
  
  
  
  4.   // 形参
    5. 
  
  
  
  
  5.   std::vector> loaders_params = {
    6. 
  
  
  
  
  6.       process_string(),
    7. 
  
  
  
  
  7.       FIXED_ONE_BYTE_STRING(isolate_, "getLinkedBinding"),
    8. 
  
  
  
  
  8.       FIXED_ONE_BYTE_STRING(isolate_, "getInternalBinding"),
    9. 
  
  
  
  
  9.       primordials_string()};
    10. 
  
  
  
  
  10.   // 实参
    11. 
  
  
  
  
  11.   std::vector> loaders_args = {
    12. 
  
  
  
  
  12.       process_object(),
    13. 
  
  
  
  
  13.       NewFunctionTemplate(binding::GetLinkedBinding)
    14. 
  
  
  
  
  14.           ->GetFunction(context())
    15. 
  
  
  
  
  15.           .ToLocalChecked(),
    16. 
  
  
  
  
  16.       NewFunctionTemplate(binding::GetInternalBinding)
    17. 
  
  
  
  
  17.           ->GetFunction(context())
    18. 
  
  
  
  
  18.           .ToLocalChecked(),
    19. 
  
  
  
  
  19.       primordials()};
    20. 
  
  
  
  
  20. 
  
  
  
  
  21.   // 执行 internal/bootstrap/loaders.js
    22. 
  
  
  
  
  22.   Local loader_exports;
    23. 
  
  
  
  
  23.   if (!ExecuteBootstrapper(
    24. 
  
  
  
  
  24.            this, "internal/bootstrap/loaders", &loaders_params, &loaders_args)
    25. 
  
  
  
  
  25.            .ToLocal(&loader_exports)) {
    26. 
  
  
  
  
  26.     return MaybeLocal();
    27. 
  
  
  
  
  27.   }
    28. 
  
  
  
  
  28.   // ...
    29. 
  
  
  
  
  29. }
    30.

ExecuteBootstrapper 会读取 internal/bootstrap/loaders.js 的内容，并且封装到一个函数中，这个函数如下

 
 
 
 
    
  
  
  
  
  1. function (process, getLinkedBinding, getInternalBinding, primordials) {
    2. 
  
  
  
  
  2.     // internal/bootstrap/loaders.js 的内容
    3. 
  
  
  
  
  3. }
    4.

然后执行这个参数，并传入四个实参。我们看看 internal/bootstrap/loaders.js 执行后返回了什么。

 
 
 
 
    
  
  
  
  
  1. const loaderExports = {
    2. 
  
  
  
  
  2.   // 加载 C++ 模块
    3. 
  
  
  
  
  3.   internalBinding,
    4. 
  
  
  
  
  4.   // 原生 JS 模块管理器
    5. 
  
  
  
  
  5.   NativeModule,
    6. 
  
  
  
  
  6.   // 原生 JS 加载器
    7. 
  
  
  
  
  7.   require: nativeModuleRequire
    8. 
  
  
  
  
  8. };
    9.

返回了两个模块加载器和一个模块管理器。接着 Node.js 把他们存起来，后续使用。

 
 
 
 
    
  
  
  
  
  1. // 保存函数执行的返回结果
    2. 
  
  
  
  
  2. Local loader_exports;
    3. 
  
  
  
  
  3. if (!ExecuteBootstrapper(
    4. 
  
  
  
  
  4.          this, "internal/bootstrap/loaders", &loaders_params, &loaders_args)
    5. 
  
  
  
  
  5.          .ToLocal(&loader_exports)) {
    6. 
  
  
  
  
  6.   return MaybeLocal();
    7. 
  
  
  
  
  7. }
    8. 
  
  
  
  
  8. Local loader_exports_obj = loader_exports.As();
  
  
  
  
  9. // 获取 C++ 模块加载器
    10. 
  
  
  
  
  10. Local internal_binding_loader = loader_exports_obj->Get(context(), internal_binding_string())
    11. 
  
  
  
  
  11.         .ToLocalChecked();
    12. 
  
  
  
  
  12. // 保存 C++ 模块加载器set_internal_binding_loader(internal_binding_loader.As());
    13. 
  
  
  
  
  13. // 获取原生 JS 加载器
    14. 
  
  
  
  
  14. Local require = loader_exports_obj->Get(context(), require_string()).ToLocalChecked();
    15. 
  
  
  
  
  15. // 保存原生 JS 加载器set_native_module_require(require.As());
    16. 
 
 
 
 
    1.3 执行用户 JS
    Node.js 初始化完毕后最终会通过以下代码执行用户的代码。
     
 
 
 
      
  
  
  
  
    1. StartExecution(env, "internal/main/run_main_module")
      2. 
 
 
 
 
    看看 StartExecution。
     
 
 
 
      
  
  
  
  
    1. MaybeLocal StartExecution(Environment* env, const char* main_script_id) {
      2. 
  
  
  
  
    2.   EscapableHandleScope scope(env->isolate());
      3. 
  
  
  
  
    3.   CHECK_NOT_NULL(main_script_id);
      4. 
  
  
  
  
    4. 
  
  
  
  
    5.   std::vector> parameters = {
      6. 
  
  
  
  
    6.       env->process_string(),
      7. 
  
  
  
  
    7.       // require 函数
      8. 
  
  
  
  
    8.       env->require_string(),
      9. 
  
  
  
  
    9.       env->internal_binding_string(),
      10. 
  
  
  
  
    10.       env->primordials_string(),
      11. 
  
  
  
  
    11.       FIXED_ONE_BYTE_STRING(env->isolate(), "markBootstrapComplete")};
      12. 
  
  
  
  
    12. 
  
  
  
  
    13.   std::vector> arguments = {
      14. 
  
  
  
  
    14.       env->process_object(),
      15. 
  
  
  
  
    15.       // 原生 JS 和 C++ 模块加载器
      16. 
  
  
  
  
    16.       env->native_module_require(),
      17. 
  
  
  
  
    17.       env->internal_binding_loader(),
      18. 
  
  
  
  
    18.       env->primordials(),
      19. 
  
  
  
  
    19.       env->NewFunctionTemplate(MarkBootstrapComplete)
      20. 
  
  
  
  
    20.           ->GetFunction(env->context())
      21. 
  
  
  
  
    21.           .ToLocalChecked()};
      22. 
  
  
  
  
    22. 
  
  
  
  
    23.   return scope.EscapeMaybe(
      24. 
  
  
  
  
    24.       ExecuteBootstrapper(env, main_script_id, ¶meters, &arguments));
      25. 
  
  
  
  
    25. }
      26. 
 
 
 
 
    传入了两个加载器，然后执行 run_main_module.js。核心代码如下
     
 
 
 
      
  
  
  
  
    1. require('internal/modules/cjs/loader').Module.runMain(process.argv[1]);
      2. 
 
 
 
 
    Module.runMain 的代码如下
     
 
 
 
      
  
  
  
  
    1. function executeUserEntryPoint(main = process.argv[1]) {
      2. 
  
  
  
  
    2.   Module._load(main, null, true);
      3. 
  
  
  
  
    3. }
      4. 
 
 
 
 
    最终通过 _load 完成用户代码的加载和执行，下面我们具体分析各种加载器。
    

    2 模块加载的实现
    

    我们平时都是通过 require 加载模块，require 帮我们处理一切，其实 Node.js 中有很多种类型的模块，下面我们逐个介绍。
    2.1 JSON 模块
     
 
 
 
      
  
  
  
  
    1. Module._extensions['.json'] = function(module, filename) {
      2. 
  
  
  
  
    2.   const content = fs.readFileSync(filename, 'utf8');
      3. 
  
  
  
  
    3. 
  
  
  
  
    4.   try {
      5. 
  
  
  
  
    5.     module.exports = JSONParse(stripBOM(content));
      6. 
  
  
  
  
    6.   } catch (err) {
      7. 
  
  
  
  
    7.     err.message = filename + ': ' + err.message;
      8. 
  
  
  
  
    8.     throw err;
      9. 
  
  
  
  
    9.   }
      10. 
  
  
  
  
    10. };
      11. 
 
 
 
 
    JSON 模块的实现很简单，读取文件的内容，解析一下就可以了。
    2.2 用户 JS 模块
    我们看到为什么在写代码的时候可以直接使用 require 函数，不是因为 require 是全局变量，而是我们写的代码会被封装到一个函数里执行，require 和 module.exports 等变量都是函数的形参，在执行我们代码时， Node.js 会传入实参，所以我们就可以使用这些变量了。require 函数可以加载用户自定义的 JS，也可以加载原生 JS，比如net，不过 Node.js 会优先查找原生 JS。
    2.3 原生 JS 模块
    原生 JS 模块和用户 JS 模块的加载原理是类似的，但是也有些不一样的地方，我们看到执行原生 JS 模块代码时，传入的实参和加载用户 JS 时是不一样的。首先 require 变量的值是一个原生 JS 模块加载器，所以原生 JS 模块里通过 require 只能加载 原生 JS 模块。另外还有另一个实参也需要关注，那就是 internalBinding，internalBinding 用于加载 C++ 模块，所以在原生 JS 里可以通过 internalBinding 加载 C++模块。
    2.4 C++ 模块
    

    2.5 Addon 模块
    

    后记：模块机制在任何语言里都是非常基础且重要的部分，深入理解 Node.js 的模块机制原理，我们知道 require 的时候到时候发生了什么，如果你对模块加载的具体实现感兴趣，可以去阅读 Node.js 的源码，也可以看一下 https://github.com/theanarkh/js_runtime_loader 这个仓库。
                
    
                网站栏目：聊聊Node.js的模块机制
                
    
                网页路径：http://www.shufengxianlan.com/qtweb/news15/537115.html
            
    
            
    
                网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等
                                
    
            
    
                广告
                
            
    
            
    
                声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源：
                创新互联
            
    
        
        
    
            
    猜你还喜欢下面的内容
    
            
        
    
    
    
    
        
    
            
    面包屑导航知识
    
            
        
    
        
    
            
    行业网站建设
    
            
        
    
    
    


    
    
    
        成都谷歌SEO　　 　注册域名　　 　成都谷歌推广　　 　金融行业网站建设方案　　 　成都微商城　　 　微信小程序　　 　德阳电信机房　　 　成都小程序商城　　 　重庆移动网站建设　　 　成都商城网站建设　　 　成都展柜厂　　 　艾名斯智能　　 　四川审计公司　　 　南京护栏钻孔机　　 　企业画册设计制作　　 　成都微信开发　　 　网站解决方案　　 　边坡防护网厂家　　 　重庆服务器托管　　 　江油做网站