為什么需要模塊化

場景1

A同學(xué)開發(fā)了模塊a，B同學(xué)開發(fā)了模塊b，在頁面下通過如下方式進行引用

<script src="a.js"></script><script src="b.js"></script>

這時模塊a，模板b中的代碼都暴露在全局環(huán)境中，如果模塊a中定義了一個方法del。同學(xué)b并不知道，在模塊b中也定義了一個方法del。這時便造成了命名沖突的的問題。如圖

場景2

C同學(xué)開發(fā)了一個公共的工具庫utils.js，D同學(xué)開發(fā)了一個公共的組件tab.js，tab.js依賴utils.js。同學(xué)E需要使用D同學(xué)開發(fā)的tab.js，就需要通過如下方式引用

<script src="util.js"></script><script src="tab.js"></script>

同學(xué)E自己也開發(fā)了一個dailog.js同時它也依賴util.js?，F(xiàn)在頁面同時引用了dialog.js和tab.js，代碼如下。

<script src="util.js"></script><script src="dialog.js"></script><scrpt src="tab.js"></script>

同學(xué)E不僅需要同時引用這三個js文件，還必須保證文件之間的引用順序是正確的。同時，從上面的代碼我們無法直接看出模塊與模塊之間的依賴關(guān)系，如果不深入tab.js，我們無法知道tab.js到底是只依賴util.js還是dialog.js或者兩者都依賴。隨著項目逐漸增大，不同模塊之間的依賴關(guān)系則會變的越來越難以維護也會導(dǎo)致許多模塊中大量的變量都暴露在全局環(huán)境中。

模塊化的幾種實現(xiàn)方案

模塊化的規(guī)范有很多種， 如下
| 規(guī)范 | 實現(xiàn)方案 |
| --- | --- |
| CommonJS | node.js |
| AMD | Require.js |
| CMD | Sea.js
| UMD | |
| ES6 Module | |

webpack支持CommonJS，AMD，ESModule等多種模塊化方式的語法。

webpack的模塊化原理

在webpack中，一切皆模塊。下面我們通過webpack來打包以下代碼。通過對打包代碼的解析，來一步一步的了解模塊化的實現(xiàn)原理。

目錄結(jié)構(gòu)如下：

代碼如下：

// webpack.config.jsconst path = require('path');
module.exports = {  entry: 'a.js',  output: {    path: path.resolve(__dirname, "dist"),          filename: "[name].js"    },    resolve: {          modules: [path.resolve(__dirname)]    },    optimization: {          minimize: false    }}// a.jsvar b = require('b');
module.exports = b.text + ' world';// b.jsexports.text = 'hello';

在simple目錄下執(zhí)行webpack命令，會在simple目錄下生成dist/output.js文件。

// outout.js// 代碼及注釋如下
(() => {  // 所有導(dǎo)入的模塊都存儲在__webpack_modules__對象中，并且每個模塊都要一個標(biāo)識該模塊的id  var __webpack_modules__ = ({     847: ((module, __unsed_webpack_exports, __webpack_require__) => {        // 模塊a...     }),     996: ((__unused_webpack_module, exports) => {       // 模塊b...     })  })
  var __webpack_module_cache__ = {};
  function __webpack_require__(moduleId) {      // 檢查緩存中不存在847導(dǎo)出對象，防止模塊847多次執(zhí)行     if (__webpack_module_cache__[moduleId]) {        // 從緩存中返回847導(dǎo)出對象        return __webpack_module_cache__[moduleId].exports;     }
     // 1.創(chuàng)建{exports: {}}對象     // 2.像緩存中添加該對象，并讓該對象與模塊id 847相關(guān)聯(lián)     var module = __webpack_module_cache__[moduleId] = {       exports: {}     }
     // 3.通過__webpack_modules__查詢模塊847     // 4.執(zhí)行模塊847并傳入剛剛創(chuàng)建的模塊847的導(dǎo)出對象module，以及module.exports等     __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
     // 5.返回模塊847的導(dǎo)出對象     return module.exports;  }
  // 導(dǎo)入模塊847  __webpack_require__(847);})()

如上代碼我們可以知道，所有的的模塊都存儲在__webpack_modules__對象中，模塊的導(dǎo)出對象則存儲在__webpack_module_cache__對象中，我們定義的模塊都可以通過傳入moduleId來調(diào)用__webpack_require__接口來訪問該模塊以及該模塊的導(dǎo)出對象。

當(dāng)我們通過__webpack_require__接口訪問模塊847的導(dǎo)出對象時。會先判斷__webpack_module_cache__對象中有沒有該模塊的導(dǎo)出對象，如果有的話，則直接返回。如果沒有的話則會

(1)創(chuàng)建模塊847的導(dǎo)出對象

var module = {  exports: {}}

(2)將該導(dǎo)出對象添加到__webpack_module_cache__對象中

__webpack_module_cahce__[moduleId] = module

(3)(4)通過__webpack_modules__查詢模塊847并執(zhí)行

// 傳入模塊847的導(dǎo)出對象，以及require接口__webpack_modules__[moduleId](module, module.exports, __webpack_require__)

(5)返回模塊847的導(dǎo)出對象

return module.exports

圖解如下：

橘黃色背景的元素代表數(shù)據(jù)

綠色背景的元素代表函數(shù)

總結(jié)

通過模塊化的管理方式

每個模塊都通過函數(shù)封裝在自己的局部環(huán)境中。 模塊與模塊之間通過require 接口進行通信。且不用通過暴露在全局環(huán)境。

每個模塊都明確通過require接口傳入依賴的模塊，所以模塊與模塊之間的依賴關(guān)系也是非常明了的。如圖a -> b -> c -> d

模塊第1次被引用時，調(diào)用require接口會像cache中添加導(dǎo)出對象。并返回添加的導(dǎo)出對象。

模塊被第2+次引用時，調(diào)用require接口查詢cache對象時，返回cache中對應(yīng)的導(dǎo)出對象。

本文完~