[[349895]]

 本文你能學到什么

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

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

什么是 CommonJS

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

模塊分類

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

模塊加載

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

加載 Node.js 原生模塊

本文不包括直接調(diào)用內(nèi)建純C/C++模塊，也不推薦這樣使用，因為我們正常調(diào)用的原生模塊都是通過 js封裝一層，它們自己再去調(diào)用，你想直接調(diào)用的 Node.js提供的存C/C++ 內(nèi)建模塊，js 封裝的一層也都能做到。那部分內(nèi)容放在 Node.js與 C++ 那些事的文章中介紹。

require 加載普通文件模塊

require 加載 C++ 擴展文件模塊

require 加載原理(源碼分析與手寫)

require 源碼解析圖

 

畫了一個源碼導圖，可以直接跟著導圖學一遍配上文章講解，效果更佳。(導圖太大了上傳不清晰，需要找我要吧。)

require 源碼并不復雜，這里采用的是邊看源碼邊手寫的方式講解(我們最終實現(xiàn)的require 是簡易版本，一些源碼提到，但是簡易版本不會實現(xiàn))，實現(xiàn) require 其實就是實現(xiàn)整個 Node.js 的模塊加載機制，Node.js 的模塊加載機制總結(jié)下來一共八步。

網(wǎng)上一些文章只分成了3-4步，我這里做了一下細化，為了徹底搞懂我開篇提到的一些問題。

1. 基礎(chǔ)準備階段

Node.js 模塊加載的主流程都在 Module 類中，在源碼的https://github.com/nodejs/node/blob/master/lib/internal/modules/cjs/loader.js#L150 中進行了基礎(chǔ) Module 類定義，這個構(gòu)造函數(shù)中的內(nèi)容主要做一些值的初始化，我們自己對照著實現(xiàn)下，為了和源碼有一個區(qū)別，本文使用 KoalaModule 命名。

 

function KoalaModule(id = '') {  
  this.id = id;       // 這個id其實就是我們require的路徑  
  this.path = path.dirname(id);     // path是Node.js內(nèi)置模塊，用它來獲取傳入?yún)?shù)對應的文件夾路徑  
  this.exports = {};        // 導出的東西放這里，初始化為空對象  
  this.filename = null;     // 模塊對應的文件名  
  this.loaded = false;      // loaded用來標識當前模塊是否已經(jīng)加載 
}  
KoalaModule._cache = Object.create(null); //創(chuàng)建一個空的緩存對象  
KoalaModule._extensions = Object.create(null); // 創(chuàng)建一個空的擴展點名類型函數(shù)對象(后面會知道用來做什么) 

然后在源碼中你會找到 require 函數(shù),在 KoalaModule 的原型鏈上，我們實現(xiàn)下

 

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

在源碼中你會發(fā)現(xiàn)又調(diào)用了_load函數(shù)，找到源碼中的 _load 函數(shù)，(源碼位置：https://github.com/nodejs/node/blob/master/lib/internal/modules/cjs/loader.js#L724)下面的所有步驟都是在這個函數(shù)中完成調(diào)用和 return的，實現(xiàn)簡易版_load函數(shù)。

 

KoalaModule._load = function (request) {    // request是我們傳入的路勁參數(shù)  
  // 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加載之前加入緩存，這也是不會造成循環(huán)引用問題的原因，但是循環(huán)引用，這個緩存里面的exports可能還沒有或者不完整 
  KoalaModule._cache[filename] = module;  
  // 7. module.load 真正的去加載代碼  
  module.load(filename);  
  // 8. 返回模塊的module.exports   
  return module.exports;  
} 

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

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

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

這個函數(shù)源碼中比較復雜，因為 require傳遞過來的值需要一層一層的判斷，同時支持多種參數(shù)：內(nèi)置模塊，相對路徑，絕對路徑，文件夾和第三方模塊等等，如果是文件夾或者第三方模塊還要解析里面的 package.json 和 index.js。這里簡單處理，只實現(xiàn)通過相對路徑和絕對路徑來查找文件，并支持判斷文件js和json后綴名判斷:

 

KoalaModule._resolveFilename = function (request) {  
  const filename = path.resolve(request);   // 獲取傳入?yún)?shù)對應的絕對路徑  
  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;  
} 

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

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

 

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

4. 去加載 node 原生模塊

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

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

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

 

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

繼續(xù)往下看 loadNativeModule 函數(shù)的調(diào)用。

 

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;  
  }  
} 

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

然后到了 mod 的核心函數(shù)mod.compileForPublicLoader();,下面這段代碼相對源碼刪除了一些非核心部分。

 

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;    
  }   

我們重點看compileFunction這里的邏輯。該函數(shù)是node_native_module_env.cc模塊導出的函數(shù)。具體的代碼就不貼了，通過層層查找，最后到 node_native_module.cc 的NativeModuleLoader::CompileAsModule。

 

MaybeLocal<Function> NativeModuleLoader::CompileAsModule(    
    Local<Context> context,    
    const char* id,    
    NativeModuleLoader::Result* result) {    
5.    
6.  Isolate* isolate = context->GetIsolate();   
7.  // 函數(shù)的形參    
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.  // 編譯出一個函數(shù)    
16.  return LookupAndCompile(context, id, ¶meters, result);  
17.} 

我們繼續(xù)看LookupAndCompile。

 

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());    
  // 省略一些參數(shù)處理    
  // 腳本源碼    
  ScriptCompiler::Source script_source(source, origin, cached_data);    
  // 編譯出一個函數(shù)    
  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);    
}   

LookupAndCompile 函數(shù)首先找到加載模塊的源碼，然后編譯出一個函數(shù)。我們看一下LoadBuiltinModuleSource 如何查找模塊源碼的。

 

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

這里是 id 是 net，通過該 id 從 _source 中找到對應的數(shù)據(jù)，那么_source 是什么呢？Nodejs 為了提高效率，把原生 js 模塊的源碼字符串直接轉(zhuǎn)成 ascii 碼存到**內(nèi)存**里。這樣加載這些模塊的時候，就不需要硬盤 io 了。直接從內(nèi)存讀取就行。_source 的定義（在 node_javascript.cc里，負責編譯nodejs 源碼或者執(zhí)行 js2c.py 生成）。

結(jié)論：Node.js 在啟動時候直接從內(nèi)存中讀取內(nèi)容，我們通過 require 加載 net 原生模塊時，通過 NativeModule的compileForInternalLoader，最終會在 _source 中找到對應的源碼字符串，然后編譯成一個函數(shù)，然后去執(zhí)行這個函數(shù),執(zhí)行函數(shù)的時候傳遞 nativeModuleRequire和internalBinding兩個函數(shù)，nativeModuleRequire用于加載原生 js 模塊，internalBinding用于加載純C++ 編寫的內(nèi)置模塊。

 

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

5. 創(chuàng)建一個 KoalaModule 實例

如果不是原生 node 模塊，就會當作普通文件模塊加載，自己創(chuàng)建一個 KoalaModule 實例，去完成加載。

 

const module = new KoalaModule(filename); 

6. 添加緩存

我把這一小步驟單獨提出的原因，想說明的是先進行緩存的添加，然后進行的模塊代碼的加載，這樣就會出現(xiàn)下面的結(jié)論，Node.js 官網(wǎng)也有單獨介紹,可以自己試一下。

1.  main 加載a，a 在真正加載前先去緩存中占一個位置
2.  a 在正式加載時加載了 b
3.  b 又去加載了 a，這時候緩存中已經(jīng)有 a 了，所以直接返回 a.exports，這時候 exports 很有可能是不完整的內(nèi)容。
   

7. module.load 真正的去加載代碼

不在緩存，不是原生模塊，緩存已經(jīng)添加完，我們通過這個 load 函數(shù)去加載文件模塊，源碼中位置(https://github.com/nodejs/node/blob/master/lib/internal/modules/cjs/loader.js#L936)

源碼中，會有一個獲取文件擴展名的函數(shù)findLongestRegisteredExtension 這個方法的具體內(nèi)容是有擴展名的取擴展名，沒有的都按照 .js 為擴展名處理，在這個之前會判斷一下 Module._extesions 支持的擴展名，不是所有都支持。

我們自己實現(xiàn)一下 load 函數(shù)。

 

KoalaModule.prototype.load = function (filename) {  
  // 獲取文件后綴名(我們忽略掉了findLongestRegisteredExtension函數(shù)，有興趣小伙伴自己實現(xiàn))  
  const extname = path.extname(filename);  
  // 根據(jù)不同的后綴名去進行不同的處理  
  KoalaModule._extensions[extname](this, filename);  
  this.loaded = true;  
} 

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

7.1. 加載.js

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

我們自己實現(xiàn)一下執(zhí)行.js代碼。

 

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

KoalaModule._extensions 中 _compile 函數(shù)的執(zhí)行。找到對應的源碼位置(https://github.com/nodejs/node/blob/master/lib/internal/modules/cjs/loader.js#L1037)，源碼中這里還使用 proxy，我們進行一下簡單實現(xiàn)。

 

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);    // 獲取包裝后函數(shù)體  
  // vm是 Node.js 的虛擬機模塊，runInThisContext方法可以接受一個字符串并將它轉(zhuǎn)化為一個函數(shù)  
  // 返回值就是轉(zhuǎn)化后的函數(shù)，compiledWrapper是一個函數(shù)  
  const compiledWrapper = vm.runInThisContext(wrapper, {  
    filename,  
    lineOffset: 0,  
    displayErrors: true,  
  });  
  const dirname = path.dirname(filename);  
  // 調(diào)用函數(shù)，這里一定注意傳遞進的內(nèi)容。  
  compiledWrapper.call(this.exports, this.exports, this.require, this,  
    filename, dirname);  
} 

這里注意兩個地方

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

 

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

•  最終執(zhí)行代碼的函數(shù)傳遞的參數(shù)

1.  this: compiledWrapper函數(shù)是通過 call 調(diào)用的，第一個參數(shù)就是里面的this，這里我們傳入的是 this.exports，也就是 module.exports
2.  exports: compiledWrapper 函數(shù)正式接收的第一個參數(shù)是 exports，我們傳的也是 this.exports,所以 js 文件里面的 exports 也是對module.exports 的一個引用。
3.  require: 這個方法我們傳的是 this.require，其實就是KoalaModule.prototype.require 函數(shù)，也就是 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),注意這里不要忘記異常拋出 我們簡單實現(xiàn)下：

 

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

7.3  加載 .node

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

 

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

直接調(diào)了process.dlopen，該函數(shù)在node.js里定義。

 

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

找到process_methods模塊對應的是node_process_methods.cc。

 

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

這里也過多分析，放到 Node.js 和 C++ 那些事那篇文章一起講解。

8. 返回模塊的 module.exports

 

return module.exports; 

在模塊中的代碼可以修改 module.exports 的值，不管是從緩存獲取，加載原生模塊還是普通文件模塊，module.exports 都是最終的導出結(jié)果

require 原理理解后的思考

require加載是同步還是異步

這個問題我直接告訴你同步還是異步，你可能過一陣又忘記了，我之前就是這樣。看過源碼或者手寫一遍就知道了，代碼中所有文件相關(guān)操作都是使用的同步，舉幾個例子：

 

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

exports和module.exports的區(qū)別究竟是什么？

在源碼中可以發(fā)現(xiàn)，

 

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

require在執(zhí)行文件時候，傳遞的兩個參數(shù) 參數(shù)一：this.exports = {}; 參數(shù)二：this 而this就是 module 所以 module.exports = {};

所以在一個模塊沒有做任何代碼編寫之前 exports === module.exports 都是 {} ，共同指向一個引用

看一張圖理解這里更清楚：

但是大多數(shù)情況下我們開發(fā)時，經(jīng)常會這樣導出

 

exports = {  
    name:'kaola'  
} 

或者這樣寫

 

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

上面這兩種情況就是給 exports 或者 module.exports 重新賦值了，改變了引用地址，兩個屬性就不再===。

關(guān)鍵點：require一個文件，之前在手寫代碼時你會發(fā)現(xiàn)，最終導出的內(nèi)容是return module.exports;.所以你對exports的重新賦值不會改變模塊的導出內(nèi)容，只是改變了exports這個變量而已。導出內(nèi)容永遠是module.exports

require 會不會造成循環(huán)引用的問題

自行去看源碼實現(xiàn)中的第 7 步，應就懂了。

require是怎么來的，為什么可以直接在一個文件中使用require

require 到的文件，在 vm 模塊最終執(zhí)行的時，對代碼進行了一層包裹，并且把對應的參數(shù)傳遞進去執(zhí)行。

包裹后的代碼：

 

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

執(zhí)行時的代碼： 

const wrapper = this.wrap(content);    // 獲取包裝后函數(shù)體  
 // vm是nodejs的虛擬機模塊，runInThisContext方法可以接受一個字符串并將它轉(zhuǎn)化為一個函數(shù)  
 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); 

在這里小伙伴對 vm 模塊有疑問的話可以看我的下一篇文章 冷門 Node.js模塊 vm 學習必不可少。

通過代碼發(fā)現(xiàn) require 函數(shù)實際已經(jīng)傳遞到了執(zhí)行的 module 文件中，所以require 在 module 文件中可以直接調(diào)用了，同時也應該明白了為什么那幾個變量可以直接獲取了 dirname,filename 等。

學習補充

CommonJs 與 ES6Module的區(qū)別？

區(qū)別	require/exports	import/export
出現(xiàn)的時間/地點不同	2009年出生 出自CommonJS	2015年出生 出自ECMAScript2015(ES6)
不同端的使用限制	100	999
加載方式	同步加載，運行時動態(tài)加載，加載的是一個對象，對象需要在腳本運行完成后才會生成	異步加載，靜態(tài)編譯，ES6 模塊不是對象，它的對外接口只是一種靜態(tài)定義，在代碼靜態(tài)解析階段就會生成
輸出對比	輸出的是一個值的拷貝，一旦輸出一個值，模塊內(nèi)部的變化不會影響到這個值	輸出的是值的引用，JS 引擎對腳本靜態(tài)分析的時候，遇到模塊加載命令import，就會生成一個只讀引用。等到腳本真正執(zhí)行時，再根據(jù)這個只讀引用，到被加載的那個模塊里面去取值。若文件引用的模塊值改變，require 引入的模塊值不會改變，而 import 引入的模塊值會改變。
使用方式	上面手寫過程中已經(jīng)說了使用方式	import的使用方式

Node.js 中的 vm 模塊是什么？

寫不動了，喝完奶茶的動力過去了，我要去睡覺了，后面發(fā)一篇小文章介紹 vm 模塊吧！有興趣的小伙伴也可以直接去 Node.js 官網(wǎng)學習下。

總結(jié)

看源碼最好帶著一些目的，開篇的一些問題只知道結(jié)果并不都知道原因就是我寫本文的目的，看源碼的過程中也能學到一些內(nèi)容，比如一些地方你會發(fā)現(xiàn)源碼是比你寫的好，嘿嘿。require 的源碼中還是有很多細節(jié)點可以學習和分析的，比如這里忽略了 isMain 主文件判斷，啟動時候 require 的使用(這個會在另一篇文章 Node.js 的啟動源碼分析中介紹)，以及在 load 方法中執(zhí)行模塊文件時候使用到的 proxy，都可以學習下,本文是一個思路，下篇見。