這篇文章給大家介紹Node.js中Require機(jī)制的原理是什么，內(nèi)容非常詳細(xì)，感興趣的小伙伴們可以參考借鑒，希望對大家能有所幫助。

成都網(wǎng)絡(luò)公司-成都網(wǎng)站建設(shè)公司創(chuàng)新互聯(lián)建站10多年經(jīng)驗(yàn)成就非凡，專業(yè)從事網(wǎng)站建設(shè)、做網(wǎng)站，成都網(wǎng)頁設(shè)計(jì)，成都網(wǎng)頁制作，軟文平臺，一元廣告等。10多年來已成功提供全面的成都網(wǎng)站建設(shè)方案，打造行業(yè)特色的成都網(wǎng)站建設(shè)案例，建站熱線：028-86922220，我們期待您的來電！

什么是 CommonJS

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

模塊分類

•  原生(核心)模塊：Node 提供的模塊我們都稱之為原生模塊

•  內(nèi)建模塊:Node.js 原生提供的模塊中，由純 C/C++ 編寫的稱為內(nèi)建模塊

•  全局模塊：Node.js在啟動時(shí)，會生成一個(gè)全局量 process

•  除了上面兩種可以直接 require 的所有原生模塊

•  文件模塊：用戶編寫的模塊

•  普通文件模塊：node_modules 下面的模塊，或者我們自己開發(fā)時(shí)候?qū)懙拿總€(gè)文件內(nèi)容。

•   C++ 擴(kuò)展模塊：用戶自己編寫的 C++ 擴(kuò)展模塊或者第三方 C++ 擴(kuò)展模塊

模塊加載

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

加載 Node.js 原生模塊

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

require 加載普通文件模塊

require 加載 C++ 擴(kuò)展文件模塊

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

require 源碼解析圖

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

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

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

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

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

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

然后在源碼中你會找到 require 函數(shù),在 KoalaModule 的原型鏈上，我們實(shí)現(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)下面的所有步驟都是在這個(gè)函數(shù)中完成調(diào)用和 return的，實(shí)現(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 一個(gè) KoalaModule實(shí)例    // 加載完成直接返回module.exports    const module = new KoalaModule(filename);    // 6. load加載之前加入緩存，這也是不會造成循環(huán)引用問題的原因，但是循環(huán)引用，這個(gè)緩存里面的exports可能還沒有或者不完整   KoalaModule._cache[filename] = module;    // 7. module.load 真正的去加載代碼    module.load(filename);    // 8. 返回模塊的module.exports     return module.exports;  }

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

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

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

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

KoalaModule._resolveFilename = function (request) {    const filename = path.resolve(request);   // 獲取傳入?yún)?shù)對應(yīng)的絕對路徑    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. 判斷模塊是否加載過(緩存判斷)

判斷這個(gè)找到的模塊文件是否緩存過，如果緩存過，直接返回 cachedModule.exports, 這里就會想到一個(gè)問題為什么在 Node.js 中模塊重復(fù)引用也不會又性能問題，因?yàn)樽隽司彺妗?源碼位置：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 原生模塊

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

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

比如我們r(jià)equire(net),走完前面的緩存判斷就會到達(dá)這個(gè)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 是一個(gè) NativeModule 對象，這個(gè)對象很常見，在 node啟動一個(gè)文件時(shí)候也會用到(源碼位置：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;      }

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

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

我們繼續(xù)看LookupAndCompile。

MaybeLocal NativeModuleLoader::LookupAndCompile(        Local context,        const char* id,        std::vector>* parameters,        NativeModuleLoader::Result* result) {       Isolate* isolate = context->GetIsolate();     EscapableHandleScope scope(isolate);      Local source;      // 找到原生js模塊的地址      if (!LoadBuiltinModuleSource(isolate, id).ToLocal(&source)) {        return {};      }      // ‘net’ + ‘.js’    std::string filename_s = id + std::string(".js");      Local filename =          OneByteString(isolate, filename_s.c_str(), filename_s.size());      // 省略一些參數(shù)處理      // 腳本源碼      ScriptCompiler::Source script_source(source, origin, cached_data);      // 編譯出一個(gè)函數(shù)      MaybeLocal maybe_fun =         ScriptCompiler::CompileFunctionInContext(context,                                                   &script_source,                                                  parameters->size(),                                                  parameters->data(),                                                  0,                                                   nullptr,                                                   options);        Local fun = maybe_fun.ToLocalChecked();      return scope.Escape(fun);    }

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

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

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

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

5. 創(chuàng)建一個(gè) KoalaModule 實(shí)例

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

const module = new KoalaModule(filename);

6. 添加緩存

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

1. 鴻蒙官方戰(zhàn)略合作共建——HarmonyOS技術(shù)社區(qū)

2.  main 加載a，a 在真正加載前先去緩存中占一個(gè)位置

3.  a 在正式加載時(shí)加載了 b

4.  b 又去加載了 a，這時(shí)候緩存中已經(jīng)有 a 了，所以直接返回 a.exports，這時(shí)候 exports 很有可能是不完整的內(nèi)容。
   

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

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

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

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

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

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

7.1. 加載.js

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

我們自己實(shí)現(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í)行。找到對應(yīng)的源碼位置(https://github.com/nodejs/node/blob/master/lib/internal/modules/cjs/loader.js#L1037)，源碼中這里還使用 proxy，我們進(jìn)行一下簡單實(shí)現(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 的虛擬機(jī)模塊，runInThisContext方法可以接受一個(gè)字符串并將它轉(zhuǎn)化為一個(gè)函數(shù)    // 返回值就是轉(zhuǎn)化后的函數(shù)，compiledWrapper是一個(gè)函數(shù)    const compiledWrapper = vm.runInThisContext(wrapper, {      filename,      lineOffset: 0,      displayErrors: true,    });    const dirname = path.dirname(filename);    // 調(diào)用函數(shù)，這里一定注意傳遞進(jìn)的內(nèi)容。    compiledWrapper.call(this.exports, this.exports, this.require, this,      filename, dirname);  }

這里注意兩個(gè)地方

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

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

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

1. 鴻蒙官方戰(zhàn)略合作共建——HarmonyOS技術(shù)社區(qū)

2.  this: compiledWrapper函數(shù)是通過 call 調(diào)用的，第一個(gè)參數(shù)就是里面的this，這里我們傳入的是 this.exports，也就是 module.exports

3.  exports: compiledWrapper 函數(shù)正式接收的第一個(gè)參數(shù)是 exports，我們傳的也是 this.exports,所以 js 文件里面的 exports 也是對module.exports 的一個(gè)引用。

4.  require: 這個(gè)方法我們傳的是 this.require，其實(shí)就是KoalaModule.prototype.require 函數(shù)，也就是 KoalaModule._load。

5.  module: 我們傳入的是 this，也就是當(dāng)前模塊的實(shí)例。

6.  __filename：文件所在的絕對路徑。

7.  __dirname: 文件所在文件夾的絕對路徑。

以上兩點(diǎn)也是我們能在 JS 模塊文件里面直接使用這幾個(gè)變量的原因。

7.2. 加載 .json

加載 .json 文件比較簡單，直接使用 JSONParse就可以，定位到源碼位置(https://github.com/nodejs/node/blob/master/lib/internal/modules/cjs/loader.js#L1117),注意這里不要忘記異常拋出 我們簡單實(shí)現(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

我們自己實(shí)現(xiàn)的 C++ 插件或者第三方 C++ 插件，經(jīng)過編譯后會變?yōu)?node 擴(kuò)展名文件。.node 文件的本質(zhì)是動態(tài)鏈接庫，找到對應(yīng)源碼位置(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模塊對應(yīng)的是node_process_methods.cc。

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

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

8. 返回模塊的 module.exports

return module.exports;

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

require 原理理解后的思考

require加載是同步還是異步

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

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í)候，傳遞的兩個(gè)參數(shù) 參數(shù)一：this.exports = {}; 參數(shù)二：this 而this就是 module 所以 module.exports = {};

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

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

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

exports = {      name:'kaola'  }

或者這樣寫

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

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

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

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

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

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

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

包裹后的代碼：

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

執(zhí)行時(shí)的代碼：

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

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

學(xué)習(xí)補(bǔ)充

CommonJs 與 ES6Module的區(qū)別？

關(guān)于Node.js中Require機(jī)制的原理是什么就分享到這里了，希望以上內(nèi)容可以對大家有一定的幫助，可以學(xué)到更多知識。如果覺得文章不錯，可以把它分享出去讓更多的人看到。