日日操夜夜添-日日操影院-日日草夜夜操-日日干干-精品一区二区三区波多野结衣-精品一区二区三区高清免费不卡

公告:魔扣目錄網(wǎng)為廣大站長提供免費(fèi)收錄網(wǎng)站服務(wù),提交前請做好本站友鏈:【 網(wǎng)站目錄:http://www.ylptlb.cn 】, 免友鏈快審服務(wù)(50元/站),

點(diǎn)擊這里在線咨詢客服
新站提交
  • 網(wǎng)站:51998
  • 待審:31
  • 小程序:12
  • 文章:1030137
  • 會員:747

Node中如何引入一個(gè)模塊及其細(xì)節(jié)

 

在 node 環(huán)境中,有兩個(gè)內(nèi)置的全局變量無需引入即可直接使用,并且無處不見,它們構(gòu)成了 nodejs 的模塊體系: module 與 require。以下是一個(gè)簡單的示例

const fs = require('fs')  
const add = (x, y) => x + y  
module.exports = add 

雖然它們在平常使用中僅僅是引入與導(dǎo)出模塊,但稍稍深入,便可見乾坤之大。在業(yè)界可用它們做一些比較 trick 的事情,雖然我不大建議使用這些黑科技,但稍微了解還是很有必要。

  1. 如何在不重啟應(yīng)用時(shí)熱加載模塊?如 require 一個(gè) json 文件時(shí)會產(chǎn)生緩存,但是重寫文件時(shí)如何 watch
  2. 如何通過不侵入代碼進(jìn)行打印日志
  3. 循環(huán)引用會產(chǎn)生什么問題?

module wrApper

當(dāng)我們使用 node 中寫一個(gè)模塊時(shí),實(shí)際上該模塊被一個(gè)函數(shù)包裹,如下所示:

(function(exports, require, module, __filename, __dirname) {  
  // 所有的模塊代碼都被包裹在這個(gè)函數(shù)中  
  const fs = require('fs')  
  const add = (x, y) => x + y 
  module.exports = add  
}); 

因此在一個(gè)模塊中自動會注入以下變量:

  • exports
  • require
  • module
  • __filename
  • __dirname

module

調(diào)試最好的辦法就是打印,我們想知道 module 是何方神圣,那就把它打印出來!

const fs = require('fs')  
const add = (x, y) => x + y  
module.exports = add  
console.log(module) 
Node中如何引入一個(gè)模塊及其細(xì)節(jié)

 

  • module.id: 如果是 . 代表是入口模塊,否則是模塊所在的文件名,可見如下的 koa
  • module.exports: 模塊的導(dǎo)出
Node中如何引入一個(gè)模塊及其細(xì)節(jié)

 

koa module

module.exports 與 exports

? `module.exports` 與 `exports` 有什么關(guān)系?[1] ?

從以下源碼中可以看到 module wrapper 的調(diào)用方 module._compile 是如何注入內(nèi)置變量的,因此根據(jù)源碼很容易理解一個(gè)模塊中的變量:

  • exports: 實(shí)際上是 module.exports 的引用
  • require: 大多情況下是 Module.prototype.require
  • module
  • __filename
  • __dirname: path.dirname(__filename)
// <node_internals>/internal/modules/cjs/loader.js:1138  
Module.prototype._compile = function(content, filename) {  
  // ...  
  const dirname = path.dirname(filename);  
  const require = makeRequireFunction(this, redirects);  
  let result;  
  // 從中可以看出:exports = module.exports  
  const exports = this.exports;  
  const thisValue = exports;  
  const module = this;  
  if (requireDepth === 0) statCache = new Map();  
  if (inspectorWrapper) {  
    result = inspectorWrapper(compiledWrapper, thisValue, exports,  
                              require, module, filename, dirname);  
  } else {  
    result = compiledWrapper.call(thisValue, exports, require, module,  
                                  filename, dirname);  
  }  
  // ...  
} 

require

通過 node 的 REPL 控制臺,或者在 VSCode 中輸出 require 進(jìn)行調(diào)試,可以發(fā)現(xiàn) require 是一個(gè)極其復(fù)雜的對象

Node中如何引入一個(gè)模塊及其細(xì)節(jié)

 

require

從以上 module wrapper 的源碼中也可以看出 require 由 makeRequireFunction 函數(shù)生成,如下

// <node_internals>/internal/modules/cjs/helpers.js:33  
function makeRequireFunction(mod, redirects) {  
  const Module = mod.constructor;  
  let require;  
  if (redirects) {  
    // ...  
  } else { 
     // require 實(shí)際上是 Module.prototype.require  
    require = function require(path) {  
      return mod.require(path);  
    };  
  }  
  function resolve(request, options) { // ... }  
  require.resolve = resolve;  
  function paths(request) {  
    validateString(request, 'request');  
    return Module._resolveLookupPaths(request, mod);  
  }  
  resolve.paths = paths;  
  require.main = process.mainModule;  
  // Enable support to add extra extension types.  
  require.extensions = Module._extensions;  
  require.cache = Module._cache;  
  return require;  
} 

? 關(guān)于 require 更詳細(xì)的信息可以去參考官方文檔: Node API: require[2] ?

require(id)

require 函數(shù)被用作引入一個(gè)模塊,也是平常最常見最常用到的函數(shù)

// <node_internals>/internal/modules/cjs/loader.js:1019  
Module.prototype.require = function(id) { 
   validateString(id, 'id');  
  if (id === '') {  
    throw new ERR_INVALID_ARG_VALUE('id', id,  
                                    'must be a non-empty string');  
  }  
  requireDepth++;  
  try {  
    return Module._load(id, this, /* isMain */ false);  
  } finally { 
     requireDepth--;  
  }  
} 

而 require 引入一個(gè)模塊時(shí),實(shí)際上通過 Module._load 載入,大致的總結(jié)如下:

  1. 如果 Module._cache 命中模塊緩存,則直接取出 module.exports,加載結(jié)束
  2. 如果是 NativeModule,則 loadNativeModule 加載模塊,如 fs、http、path 等模塊,加載結(jié)束
  3. 否則,使用 Module.load 加載模塊,當(dāng)然這個(gè)步驟也很長,下一章節(jié)再細(xì)講
// <node_internals>/internal/modules/cjs/loader.js:879  
Module._load = function(request, parent, isMain) {  
  let relResolveCacheIdentifier;  
  if (parent) {  
    // ...  
  }  
  const filename = Module._resolveFilename(request, parent, isMain);  
  const cachedModule = Module._cache[filename];  
  // 如果命中緩存,直接取緩存  
  if (cachedModule !== undefined) {  
    updateChildren(parent, cachedModule, true);  
    return cachedModule.exports;  
  }  
  // 如果是 NativeModule,加載它  
  const mod = loadNativeModule(filename, request);  
  if (mod && mod.canBeRequiredByUsers) return mod.exports;  
  // Don't call updateChildren(), Module constructor already does.  
  const module = new Module(filename, parent);  
  if (isMain) {  
    process.mainModule = module;  
    module.id = '.';  
  }  
  Module._cache[filename] = module;  
  if (parent !== undefined) { // ... }  
  let threw = true;  
  try {  
    if (enableSourceMaps) {  
      try {  
        // 如果不是 NativeModule,加載它  
        module.load(filename);  
      } catch (err) {  
        rekeySourceMap(Module._cache[filename], err);  
        throw err; /* node-do-not-add-exception-line */  
      }  
    } else {  
      module.load(filename);  
    }  
    threw = false;  
  } finally {  
    // ...  
  }  
  return module.exports;  
}; 

require.cache

「當(dāng)代碼執(zhí)行 require(lib) 時(shí),會執(zhí)行 lib 模塊中的內(nèi)容,并作為一份緩存,下次引用時(shí)不再執(zhí)行模塊中內(nèi)容」。

這里的緩存指的就是 require.cache,也就是上一段指的 Module._cache

// <node_internals>/internal/modules/cjs/loader.js:899  
require.cache = Module._cache; 

這里有個(gè)小測試:

? 有兩個(gè)文件: index.js 與 utils.js。utils.js 中有一個(gè)打印操作,當(dāng) index.js 引用 utils.js 多次時(shí),utils.js 中的打印操作會執(zhí)行幾次。代碼示例如下 ?

「index.js」

// index.js  
// 此處引用兩次  
require('./utils')  
require('./utils') 

「utils.js」

// utils.js  
console.log('被執(zhí)行了一次') 

「答案是只執(zhí)行了一次」,因此 require.cache,在 index.js 末尾打印 require,此時(shí)會發(fā)現(xiàn)一個(gè)模塊緩存

// index.js  
require('./utils')  
require('./utils')  
console.log(require) 
Node中如何引入一個(gè)模塊及其細(xì)節(jié)

 

那回到本章剛開始的問題:

? 如何不重啟應(yīng)用熱加載模塊呢? ?

答:「刪掉 Module._cache」,但同時(shí)會引發(fā)問題,如這種 一行 delete require.cache 引發(fā)的內(nèi)存泄漏血案[3]

所以說嘛,這種黑魔法大幅修改核心代碼的東西開發(fā)環(huán)境玩一玩就可以了,千萬不要跑到生產(chǎn)環(huán)境中去,畢竟黑魔法是不可控的。

總結(jié)

  1. 模塊中執(zhí)行時(shí)會被 module wrapper 包裹,并注入全局變量 require 及 module 等
  2. module.exports 與 exports 的關(guān)系實(shí)際上是 exports = module.exports
  3. require 實(shí)際上是 module.require
  4. require.cache 會保證模塊不會被執(zhí)行多次
  5. 不要使用 delete require.cache 這種黑魔法

分享到:
標(biāo)簽:Node
用戶無頭像

網(wǎng)友整理

注冊時(shí)間:

網(wǎng)站:5 個(gè)   小程序:0 個(gè)  文章:12 篇

  • 51998

    網(wǎng)站

  • 12

    小程序

  • 1030137

    文章

  • 747

    會員

趕快注冊賬號,推廣您的網(wǎng)站吧!
最新入駐小程序

數(shù)獨(dú)大挑戰(zhàn)2018-06-03

數(shù)獨(dú)一種數(shù)學(xué)游戲,玩家需要根據(jù)9

答題星2018-06-03

您可以通過答題星輕松地創(chuàng)建試卷

全階人生考試2018-06-03

各種考試題,題庫,初中,高中,大學(xué)四六

運(yùn)動步數(shù)有氧達(dá)人2018-06-03

記錄運(yùn)動步數(shù),積累氧氣值。還可偷

每日養(yǎng)生app2018-06-03

每日養(yǎng)生,天天健康

體育訓(xùn)練成績評定2018-06-03

通用課目體育訓(xùn)練成績評定