1 什么是模塊化編程

2 為什么要模塊化

3 AMD

4 CommonJS

5 總結(jié)

了解一個(gè)技術(shù)，首先要了解這個(gè)技術(shù)產(chǎn)生的背景及解決的問題，而不應(yīng)該只是單純的知道該怎么用。之前的狀態(tài)可能就是只是為了了解而了解，并不知道實(shí)際產(chǎn)生的原因及帶來的好處，所以今天就來總結(jié)一下。

1 什么是模塊化編程

來看百度百科的定義

模塊化程序設(shè)計(jì)是指在進(jìn)行程序設(shè)計(jì)時(shí)將一個(gè)大程序按照功能劃分為若干小程序模塊，每個(gè)小程序模塊完成一個(gè)確定的功能，并在這些模塊之間建立必要的聯(lián)系，通過模塊的互相協(xié)作完成整個(gè)功能的程序設(shè)計(jì)方法。

比如 java 的 import，C# 的 using。我的理解是通過模塊化編程，可以將不同的功能獨(dú)立出來，修改某個(gè)功能時(shí)不會(huì)對其他功能產(chǎn)生影響。

2 為什么要模塊化

來看下面一個(gè)例子

// A.jsfunction sayWord(type){
    if(type === 1){
        console.log("hello");
    }else if(type === 2){
        console.log("world");
    }
}// B.jsfunction Hello(){
    sayWord(1);
}// C.jsHello()

假設(shè)上面三個(gè)文件，B.js 引用了 A.js 里面的內(nèi)容，C.js 又引用了 B.js 里面的內(nèi)容，如果編寫 C.js 的人只知道引用了 B.js，那他就不會(huì)引用 A.js 就會(huì)導(dǎo)致程序出錯(cuò)，而且文件的引用順序也不能出錯(cuò)。給整體代碼的調(diào)試修改帶來不便。

還有個(gè)問題，上述代碼暴露了兩個(gè)全局變量，容易造成全局變量的污染

3 AMD

AMD 即 Asynchronous Module Definition（異步模塊定義）。采取異步加載的方式加載模塊，模塊的加載不會(huì)影響它后面的語句執(zhí)行。

假設(shè)下面這種情況

// util.jsdefine(function(){
    return {
        getFormatDate:function(date,type){
            if(type === 1){                return '2018-08-9'
            }            if(type === 2){                return '2018 年 8 月 9 日'
            }
        }
    }
})// a-util.jsdefine(['./util.js'],function(util){
    return {
        aGetFormatDate:function(date){
            return util.getFormatDate(date,2)
        }
    }
})// a.jsdefine(['./a-util.js'],function(aUtil){
    return {
        printDate:function(date){
            console.log(aUtil.aGetFormatDate(date))
        }
    }
})// main.jsrequire(['./a.js'],function(a){
    var date = new Date()
    a.printDate(date)
})
console.log(1);// 使用// <script src = "/require.min.js" data-main="./main.js"></script>

頁面上先打印 1，然后才會(huì)打印 2018 年 8 月 9 日。因此 AMD 的加載并不會(huì)影響后續(xù)的語句執(zhí)行。

如果不是異步加載會(huì)出現(xiàn)什么情況呢

var a = require('a');
console.log(1)

后面的語句需要等待 a 加載完成才能執(zhí)行，如果加載時(shí)間過長，整個(gè)程序都會(huì)卡在這。因此，瀏覽器不能同步加載資源，這也是 AMD 的產(chǎn)生背景。

AMD 是在瀏覽器端實(shí)現(xiàn)模塊化開發(fā)的規(guī)范。由于該規(guī)范不是 JavaScript 原始支持的，使用 AMD 規(guī)范進(jìn)行開發(fā)的時(shí)候需要引入第三方的庫函數(shù)，也就是 RequireJS。

RequireJS 主要解決的問題

• 使 JS 異步加載，避免頁面失去響應(yīng)

• 管理代碼之間的依賴性，有利于代碼的編寫和維護(hù)

下面來看看如何使用 require.js

要想使用 require.js，首先要 define

// ? 代表該參數(shù)可選
    define(id?, dependencies?, factory);

• id：指的是定義的模塊的名字

• dependencies：是定義的模塊所依賴模塊的數(shù)組

• factory：為模塊初始化要執(zhí)行的函數(shù)或?qū)ο?。如果為函?shù)，它應(yīng)該只被執(zhí)行一次。如果是對象，此對象應(yīng)該為模塊的輸出值。

  具體的規(guī)范說明可以參考 AMD (中文版)
  舉個(gè)例子，創(chuàng)建一個(gè)名為 “alpha” 的模塊，使用了 require，exports，和名為 “beta” 的模塊:

define("alpha", ["require", "exports", "beta"], function (require, exports, beta) {
       exports.verb = function() {
           return beta.verb();           //Or:
           return require("beta").verb();
       }
   });

一個(gè)返回對象的匿名模塊：

define(["alpha"], function (alpha) {
       return {
         verb: function(){
           return alpha.verb() + 2;
         }
       };
   });

一個(gè)沒有依賴性的模塊可以直接定義對象：

define({
     add: function(x, y){
       return x + y;
     }
   });

如何使用

AMD 采用 require 語句加載模塊

require([module],callback);

• module：是一個(gè)數(shù)組，里面的成員是要加載的模塊

• callback：加載成功之后的回調(diào)函數(shù)

例如

require(['./a.js'],function(a){
    var date = new Date()
    a.printDate(date)
})

具體的使用方法如下

// util.jsdefine(function(){
    return {
        getFormatDate:function(date,type){
            if(type === 1){                return '2018-08-09'
            }            if(type === 2){                return '2018 年 8 月 9 日'
            }
        }
    }
})// a-util.jsdefine(['./util.js'],function(util){
    return {
        aGetFormatDate:function(date){
            return util.getFormatDate(date,2)
        }
    }
})// a.jsdefine(['./a-util.js'],function(aUtil){
    return {
        printDate:function(date){
            console.log(aUtil.aGetFormatDate(date))
        }
    }
})// main.jsrequire(['./a.js'],function(a){
    var date = new Date()
    a.printDate(date)
})// 使用// 

假設(shè)這里有 4 個(gè)文件，util.js，a-util.js 引用了 util.js，a.js 引用了 a-util.js，main.js 引用了 a.js。

其中，data-main 屬性的作用是加載網(wǎng)頁程序的主模塊。

上例演示了一個(gè)主模塊最簡單的寫法，默認(rèn)情況下，require.js 假設(shè)依賴和主模塊在同一個(gè)目錄。

使用 require.config() 方法可以對模塊的加載行為進(jìn)行自定義。require.config() 就寫在主模塊（main.js）的頭部，參數(shù)是一個(gè)對象，這個(gè)對象的 paths 屬性指定各個(gè)模塊的加載路徑

require.config({
    paths:{        "a":"src/a.js",        "b":"src/b.js"
    }
})

還有一種方法是改變基礎(chǔ)目錄（baseUrl）

require.config({

　　　　baseUrl: "src",

　　　　paths: {

　　　　　　"a": "a.js",
　　　　　　"b": "b.js",

　　　　}

　　});

4 CommonJS

commonJS 是 nodejs 的模塊化規(guī)范，現(xiàn)在被大量用在前端，由于構(gòu)建工具的高度自動(dòng)化，使得使用 npm 的成本非常低。commonJS 不會(huì)異步加載 JS，而是同步一次性加載出來

在 commonJS 中，有一個(gè)全局性的方法 require()，用于加載模塊，例如

const util = require('util');

然后，就可以調(diào)用 util 提供的方法了

const util = require('util');var date = new date();
util.getFormatDate(date,1);

commonJS 對于模塊的定義分三種，模塊定義（exports），模塊引用（require）和模塊標(biāo)示（module）

exports() 對象用于導(dǎo)出當(dāng)前模塊的變量或方法，唯一的導(dǎo)出口。require() 用來引入外部模塊。module 對象代表模塊本身。

舉個(gè)栗子

// util.jsmodule.exports = {
    getFormatDate:function(date, type){
         if(type === 1){                return '2017-06-15'
          }          if(type === 2){                return '2017 年 6 月 15 日'
          }
    }
}// a-util.jsconst util = require('util.js')
module.exports = {
    aGetFormatDate:function(date){
        return util.getFormatDate(date,2)
    }
}

或者下面這種方式

 // foobar.js
 // 定義行為
 function foobar(){
         this.foo = function(){
                 console.log('Hello foo');
        }  
         this.bar = function(){
                 console.log('Hello bar');
          }
 } // 把 foobar 暴露給其它模塊
 exports.foobar = foobar;// main.js//使用文件與模塊文件在同一目錄var foobar = require('./foobar').foobar,
test = new foobar();
test.bar(); // 'Hello bar'

5 總結(jié)

CommonJS 則采用了服務(wù)器優(yōu)先的策略，使用同步方式加載模塊，而 AMD 采用異步加載的方式。所以如果需要使用異步加載 js 的話建議使用 AMD，而當(dāng)項(xiàng)目使用了 npm 的情況下建議使用 CommonJS。

相關(guān)推薦：

論JavaScript模塊化編程

requireJS框架模塊化編程實(shí)例詳解

以上是什么是模塊化編程？js 模塊化編程的總結(jié)的詳細(xì)內(nèi)容。更多信息請關(guān)注PHP中文網(wǎng)其他相關(guān)文章！