成人免费xxxxx在线视频软件_久久精品久久久_亚洲国产精品久久久_天天色天天色_亚洲人成一区_欧美一级欧美三级在线观看

徹底搞懂Node.js中的Require機制

作者：佚名
開發 前端
本文學完后看看是否都搞能懂。最好跟著練習一遍手寫 require 源碼，美滋滋。

[[349895]]

 本文你能學到什么

  •  自己手寫實現一個 require，面試用也可以。
  •  如何看 Node.js 源碼
  •  require 函數是如何產生的？為什么在 module 中可以直接使用。
  •  require 加載原生模塊時候如何處理的，為什么 require('net') 可以直接找到
  •  Node.js 中 require 會出現循環引用問題嗎？
  •  require 是同步還是異步的？為什么？
  •  exports 和 module.exports 的區別是什么？
  •  你知道 require 加載的過程中使用了 vm 模塊嗎？vm 模塊是做什么的？vm 模塊除了 require 源碼用到還有哪些應用場景。

請注意我上面提出的問題，本文學完后看看是否都搞能懂。最好跟著練習一遍手寫 require 源碼，美滋滋。

什么是 CommonJS

每一個文件就是一個模塊，擁有自己獨立的作用域，變量，以及方法等，對其他的模塊都不可見。CommonJS 規范規定，每個模塊內部，module 變量代表當前模塊。這個變量是一個對象，它的exports屬性（即module.exports）是對外的接口。

模塊分類

  •  原生(核心)模塊：Node 提供的模塊我們都稱之為原生模塊
    •  內建模塊:Node.js 原生提供的模塊中，由純 C/C++ 編寫的稱為內建模塊
    •  全局模塊：Node.js在啟動時，會生成一個全局量 process
    •  除了上面兩種可以直接 require 的所有原生模塊
  •  文件模塊：用戶編寫的模塊
    •  普通文件模塊：node_modules 下面的模塊，或者我們自己開發時候寫的每個文件內容。
    •   C++ 擴展模塊：用戶自己編寫的 C++ 擴展模塊或者第三方 C++ 擴展模塊

模塊加載

介紹了上面的模塊分類，正常應該到介紹不同模塊的加載環節，這里不這樣,只列出目錄。先帶你看一遍源碼，再手寫一下，然后我想你自己總結一下這幾種模塊的加載區別。

加載 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#L150 中進行了基礎 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, /* isMain */ 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.   /*const mod = loadNativeModule(filename, request);  
  11.    if (mod && mod.canBeRequiredByUsers) return mod.exports;*/    
  12.   // 5. 如果緩存不存在，我們需自行加載模塊，new 一個 KoalaModule實例  
  13.   // 加載完成直接返回module.exports  
  14.   const module = new KoalaModule(filename);  
  15.   // 6. load加載之前加入緩存，這也是不會造成循環引用問題的原因，但是循環引用，這個緩存里面的exports可能還沒有或者不完整 
  16.   KoalaModule._cache[filename] = module;  
  17.   // 7. module.load 真正的去加載代碼  
  18.   module.load(filename);  
  19.   // 8. 返回模塊的module.exports   
  20.   return module.exports;  
  21. } 

這個函數的源碼中有一些其他邏輯的細節判斷，有興趣的小伙伴再學習下，我提出了核心主干。

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

找到源碼中的 _resolveFilename 函數，這個方法是通過用戶傳入的require參數來解析到真正的文件地址。(源碼地址：https://github.com/nodejs/node/blob/master/lib/internal/modules/cjs/loader.js#L816)

這個函數源碼中比較復雜，因為 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;  
  16. } 

3. 判斷模塊是否加載過(緩存判斷)

判斷這個找到的模塊文件是否緩存過，如果緩存過，直接返回 cachedModule.exports, 這里就會想到一個問題為什么在 Node.js 中模塊重復引用也不會又性能問題，因為做了緩存。(源碼位置：https://github.com/nodejs/node/blob/master/lib/internal/modules/cjs/loader.js#L747)

 

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

4. 去加載 node 原生模塊

如果沒有進行緩存過，會調用一個加載原生模塊的函數，這里分析一下。

注意：第四部分代碼我們沒有進行手寫實現，在_load中進行了注釋，但是這里進行了一遍分析，我們寫的代碼是如何調用到原生模塊，本部分涉及到你可能會不想看的C內容，其實也可以忽略掉，過一遍就能知道最后的結論為什么是那樣了，不然看了書記不住為什么這樣。

比如我們require(net),走完前面的緩存判斷就會到達這個loadNativeModule函數(源碼位置:https://github.com/nodejs/node/blob/802c98d65de40f245781f591a0b3b38336d1af94/lib/internal/modules/cjs/helpers.js#L31)

 

  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.   }  
  9. } 

mod 是一個 NativeModule 對象，這個對象很常見，在 node啟動一個文件時候也會用到(源碼位置：https://github.com/nodejs/node/blob/802c98d65de40f245781f591a0b3b38336d1af94/lib/internal/bootstrap/loaders.js#L161)

然后到了 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#L936)

源碼中，會有一個獲取文件擴展名的函數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;  
  7. } 

獲取到擴展名之后，根據不通的擴展名去執行不同的擴展名函數，源碼中支持的擴展名有.js,.json,.node;

7.1. 加載.js

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

我們自己實現一下執行.js代碼。

 

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

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);  
  21. } 

這里注意兩個地方

  •  使用 vm 進行模塊代碼的執行，模塊代碼外面進行了一層包裹,以便注入一些變量。

 

  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#L1117),注意這里不要忘記異常拋出 我們簡單實現下：

 

  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.   }  
  8. } 

7.3  加載 .node

我們自己實現的 C++ 插件或者第三方 C++ 插件，經過編譯后會變為.node 擴展名文件。.node 文件的本質是動態鏈接庫，找到對應源碼位置(https://github.com/nodejs/node/blob/master/lib/internal/modules/cjs/loader.js#L1135)

 

  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'  
  3. } 

或者這樣寫

 

  1. module.export = {  
  2.     value:'程序員成長指北‘  
  3. } 

上面這兩種情況就是給 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，都可以學習下,本文是一個思路，下篇見。

 

 

責任編輯：龐桂玉 來源： 前端大全
Node.jsRequire前端
相關推薦

2020-08-31 15:00:17

Node.jsrequire前端

2022-02-05 21:15:59

Node.jsrequire函數

2021-09-26 05:06:04

Node.js模塊機制

2019-08-15 14:42:24

進程線程javascript

2017-08-16 10:36:10

JavaScriptNode.js事件驅動

2024-01-05 08:49:15

Node.js異步編程

2021-05-21 09:36:42

開發技能代碼

2016-08-11 14:02:02

NodeJS前端

2020-04-15 15:48:03

Node.jsstream前端

2013-11-01 09:34:56

Node.js技術

2015-03-10 10:59:18

Node.js開發指南基礎介紹

2017-03-19 16:40:28

漏洞Node.js內存泄漏

2017-03-20 13:43:51

Node.js內存泄漏

2020-05-29 15:33:28

Node.js框架JavaScript

2024-01-03 13:39:00

JS，Javascrip算法

2021-06-10 07:51:07

Node.js循環機制

2012-02-03 09:25:39

Node.js

2021-12-25 22:29:57

Node.js 微任務處理事件循環

2021-03-04 23:12:57

Node.js異步迭代器開發

2020-01-03 16:04:10

Node.js內存泄漏
點贊
收藏

51CTO技術棧公眾號

主站蜘蛛池模板： 亚洲国产一区二区三区在线观看 | 国产精品自拍av | 久久久一区二区三区 | 午夜影院普通用户体验区 | 亚洲人在线观看视频 | 亚洲精品电影在线观看 | 国产一区二区三区四区 | 日本一二区视频 | 中文字幕在线播放不卡 | 国产在线观看网站 | 在线一区二区三区 | 欧美理伦片在线播放 | 超碰97av| 日韩在线免费视频 | 97视频成人 | 99精品国产一区二区三区 | 久久av网| 婷婷久久五月天 | 国产精品国产自产拍高清 | 在线观看成人精品 | 亚洲精品视频观看 | 国产精品久久久久久久 | 亚洲第一天堂无码专区 | 看a网站| 成人在线观看免费 | 波多野结衣一区二区三区在线观看 | 欧美日韩在线视频一区二区 | 日韩精品一区二区三区在线播放 | 亚洲精品久久 | 亚洲精品一区二区三区在线 | 国产第一区二区 | 精品欧美一区二区三区久久久 | 国产视频2021| 亚洲 一区 | 99久久99热这里只有精品 | 国产精品久久久久久久久免费樱桃 | 欧美一区二 | 日韩免费av一区二区 | 91欧美| 黄色在线观看国产 | 欧美不卡视频 |