CommonJS規(guī)范加載模塊是同步的，也就是說，只有加載完成，才能執(zhí)行后面的操作。AMD規(guī)范則是非同步加載模塊，允許指定回調(diào)函數(shù)。由于Node.js主要用于服務(wù)器編程，模塊文件一般都已經(jīng)存在于本地硬盤，所以加載起來比較快，不用考慮非同步加載的方式，所以CommonJS規(guī)范比較適用。但是，如果是瀏覽器環(huán)境，要從服務(wù)器端加載模塊，這時(shí)就必須采用非同步模式，因此瀏覽器端一般采用AMD規(guī)范。此外AMD規(guī)范比CommonJS規(guī)范在瀏覽器端實(shí)現(xiàn)要來著早。

定義暴露模塊:

//定義沒有依賴的模塊
define(function(){
   return 模塊
})

//定義有依賴的模塊
define(["module1", "module2"], function(m1, m2){
   return 模塊
})

引入使用模塊:

require(["module1", "module2"], function(m1, m2){
   使用m1/m2
})

通過比較兩者的實(shí)現(xiàn)方法，來說明使用AMD規(guī)范的好處。

未使用AMD規(guī)范

// dataService.js文件
(function (window) {
  let msg = "www.baidu.com"
  function getMsg() {
    return msg.toUpperCase()
  }
  window.dataService = {getMsg}
})(window)

 // alerter.js文件
(function (window, dataService) {
  let name = "Tom"
  function showMsg() {
    alert(dataService.getMsg() + ", " + name)
  }
  window.alerter = {showMsg}
})(window, dataService)

// main.js文件
(function (alerter) {
  alerter.showMsg()
})(alerter)

// index.html文件
Modular Demo 1: 未使用AMD(require.js)

最后得到如下結(jié)果：

這種方式缺點(diǎn)很明顯：首先會(huì)發(fā)送多個(gè)請(qǐng)求，其次引入的js文件順序不能搞錯(cuò)，否則會(huì)報(bào)錯(cuò)！

使用require.js

RequireJS是一個(gè)工具庫，主要用于客戶端的模塊管理。它的模塊管理遵守AMD規(guī)范，RequireJS的基本思想是，通過define方法，將代碼定義為模塊；通過require方法，實(shí)現(xiàn)代碼的模塊加載。
接下來介紹AMD規(guī)范在瀏覽器實(shí)現(xiàn)的步驟：

官網(wǎng): http://www.requirejs.cn/

github : https://github.com/requirejs/requirejs

然后將require.js導(dǎo)入項(xiàng)目: js/libs/require.js

|-js
  |-libs
    |-require.js
  |-modules
    |-alerter.js
    |-dataService.js
  |-main.js
|-index.html

// dataService.js文件 
// 定義沒有依賴的模塊
define(function() {
  let msg = "www.baidu.com"
  function getMsg() {
    return msg.toUpperCase()
  }
  return { getMsg } // 暴露模塊
})

//alerter.js文件
// 定義有依賴的模塊
define(["dataService"], function(dataService) {
  let name = "Tom"
  function showMsg() {
    alert(dataService.getMsg() + ", " + name)
  }
  // 暴露模塊
  return { showMsg }
})

// main.js文件
(function() {
  require.config({
    baseUrl: "js/", //基本路徑 出發(fā)點(diǎn)在根目錄下
    paths: {
      //映射: 模塊標(biāo)識(shí)名: 路徑
      alerter: "./modules/alerter", //此處不能寫成alerter.js,會(huì)報(bào)錯(cuò)
      dataService: "./modules/dataService"
    }
  })
  require(["alerter"], function(alerter) {
    alerter.showMsg()
  })
})()

// index.html文件


  
    
  
  
    
    
  

在index.html引入

此外在項(xiàng)目中如何引入第三方庫？只需在上面代碼的基礎(chǔ)稍作修改：

// alerter.js文件
define(["dataService", "jquery"], function(dataService, $) {
  let name = "Tom"
  function showMsg() {
    alert(dataService.getMsg() + ", " + name)
  }
  $("body").css("background", "green")
  // 暴露模塊
  return { showMsg }
})

// main.js文件
(function() {
  require.config({
    baseUrl: "js/", //基本路徑 出發(fā)點(diǎn)在根目錄下
    paths: {
      //自定義模塊
      alerter: "./modules/alerter", //此處不能寫成alerter.js,會(huì)報(bào)錯(cuò)
      dataService: "./modules/dataService",
      // 第三方庫模塊
      jquery: "./libs/jquery-1.10.1" //注意：寫成jQuery會(huì)報(bào)錯(cuò)
    }
  })
  require(["alerter"], function(alerter) {
    alerter.showMsg()
  })
})()

上例是在alerter.js文件中引入jQuery第三方庫，main.js文件也要有相應(yīng)的路徑配置。
小結(jié)：通過兩者的比較，可以得出AMD模塊定義的方法非常清晰，不會(huì)污染全局環(huán)境，能夠清楚地顯示依賴關(guān)系。AMD模式可以用于瀏覽器環(huán)境，并且允許非同步加載模塊，也可以根據(jù)需要?jiǎng)討B(tài)加載模塊。

CMD規(guī)范專門用于瀏覽器端，模塊的加載是異步的，模塊使用時(shí)才會(huì)加載執(zhí)行。CMD規(guī)范整合了CommonJS和AMD規(guī)范的特點(diǎn)。在 Sea.js 中，所有 JavaScript 模塊都遵循 CMD模塊定義規(guī)范。

定義暴露模塊：

//定義沒有依賴的模塊
define(function(require, exports, module){
  exports.xxx = value
  module.exports = value
})

//定義有依賴的模塊
define(function(require, exports, module){
  //引入依賴模塊(同步)
  var module2 = require("./module2")
  //引入依賴模塊(異步)
    require.async("./module3", function (m3) {
    })
  //暴露模塊
  exports.xxx = value
})

引入使用模塊：

define(function (require) {
  var m1 = require("./module1")
  var m4 = require("./module4")
  m1.show()
  m4.show()
})

官網(wǎng): http://seajs.org/

github : https://github.com/seajs/seajs

然后將sea.js導(dǎo)入項(xiàng)目: js/libs/sea.js

|-js
  |-libs
    |-sea.js
  |-modules
    |-module1.js
    |-module2.js
    |-module3.js
    |-module4.js
    |-main.js
|-index.html

// module1.js文件
define(function (require, exports, module) {
  //內(nèi)部變量數(shù)據(jù)
  var data = "atguigu.com"
  //內(nèi)部函數(shù)
  function show() {
    console.log("module1 show() " + data)
  }
  //向外暴露
  exports.show = show
})

// module2.js文件
define(function (require, exports, module) {
  module.exports = {
    msg: "I Will Back"
  }
})

// module3.js文件
define(function(require, exports, module) {
  const API_KEY = "abc123"
  exports.API_KEY = API_KEY
})

// module4.js文件
define(function (require, exports, module) {
  //引入依賴模塊(同步)
  var module2 = require("./module2")
  function show() {
    console.log("module4 show() " + module2.msg)
  }
  exports.show = show
  //引入依賴模塊(異步)
  require.async("./module3", function (m3) {
    console.log("異步引入依賴模塊3  " + m3.API_KEY)
  })
})

// main.js文件
define(function (require) {
  var m1 = require("./module1")
  var m4 = require("./module4")
  m1.show()
  m4.show()
})

最后得到結(jié)果如下：

ES6 模塊的設(shè)計(jì)思想是盡量的靜態(tài)化，使得編譯時(shí)就能確定模塊的依賴關(guān)系，以及輸入和輸出的變量。CommonJS 和 AMD 模塊，都只能在運(yùn)行時(shí)確定這些東西。比如，CommonJS 模塊就是對(duì)象，輸入時(shí)必須查找對(duì)象屬性。

export命令用于規(guī)定模塊的對(duì)外接口，import命令用于輸入其他模塊提供的功能。

/** 定義模塊 math.js **/
var basicNum = 0;
var add = function (a, b) {
    return a + b;
};
export { basicNum, add };
/** 引用模塊 **/
import { basicNum, add } from "./math";
function test(ele) {
    ele.textContent = add(99 + basicNum);
}

如上例所示，使用import命令的時(shí)候，用戶需要知道所要加載的變量名或函數(shù)名，否則無法加載。為了給用戶提供方便，讓他們不用閱讀文檔就能加載模塊，就要用到export default命令，為模塊指定默認(rèn)輸出。

// export-default.js
export default function () {
  console.log("foo");
}

// import-default.js
import customName from "./export-default";
customName(); // "foo"

模塊默認(rèn)輸出, 其他模塊加載該模塊時(shí)，import命令可以為該匿名函數(shù)指定任意名字。

它們有兩個(gè)重大差異：

① CommonJS 模塊輸出的是一個(gè)值的拷貝，ES6 模塊輸出的是值的引用。

② CommonJS 模塊是運(yùn)行時(shí)加載，ES6 模塊是編譯時(shí)輸出接口。

第二個(gè)差異是因?yàn)?CommonJS 加載的是一個(gè)對(duì)象（即module.exports屬性），該對(duì)象只有在腳本運(yùn)行完才會(huì)生成。而 ES6 模塊不是對(duì)象，它的對(duì)外接口只是一種靜態(tài)定義，在代碼靜態(tài)解析階段就會(huì)生成。

下面重點(diǎn)解釋第一個(gè)差異，我們還是舉上面那個(gè)CommonJS模塊的加載機(jī)制例子:

// lib.js
export let counter = 3;
export function incCounter() {
  counter++;
}
// main.js
import { counter, incCounter } from "./lib";
console.log(counter); // 3
incCounter();
console.log(counter); // 4

ES6 模塊的運(yùn)行機(jī)制與 CommonJS 不一樣。ES6 模塊是動(dòng)態(tài)引用，并且不會(huì)緩存值，模塊里面的變量綁定其所在的模塊。

簡(jiǎn)單來說就一句話：使用Babel將ES6編譯為ES5代碼，使用Browserify編譯打包js。

 {
   "name" : "es6-babel-browserify",
   "version" : "1.0.0"
 }

npm install babel-cli browserify -g

npm install babel-preset-es2015 --save-dev

preset 預(yù)設(shè)(將es6轉(zhuǎn)換成es5的所有插件打包)

  {
    "presets": ["es2015"]
  }

//module1.js文件
// 分別暴露
export function foo() {
  console.log("foo() module1")
}
export function bar() {
  console.log("bar() module1")
}

//module2.js文件
// 統(tǒng)一暴露
function fun1() {
  console.log("fun1() module2")
}
function fun2() {
  console.log("fun2() module2")
}
export { fun1, fun2 }

//module3.js文件
// 默認(rèn)暴露 可以暴露任意數(shù)據(jù)類項(xiàng)，暴露什么數(shù)據(jù)，接收到就是什么數(shù)據(jù)
export default () => {
  console.log("默認(rèn)暴露")
}

// app.js文件
import { foo, bar } from "./module1"
import { fun1, fun2 } from "./module2"
import module3 from "./module3"
foo()
bar()
fun1()
fun2()
module3()

使用Babel將ES6編譯為ES5代碼(但包含CommonJS語法) : babel js/src -d js/lib

使用Browserify編譯js : browserify js/lib/app.js -o js/lib/bundle.js

然后在index.html文件中引入

最后得到如下結(jié)果：

此外第三方庫(以jQuery為例)如何引入呢？
首先安裝依賴npm install jquery@1
然后在app.js文件中引入

//app.js文件
import { foo, bar } from "./module1"
import { fun1, fun2 } from "./module2"
import module3 from "./module3"
import $ from "jquery"

foo()
bar()
fun1()
fun2()
module3()
$("body").css("background", "green")

CommonJS規(guī)范主要用于服務(wù)端編程，加載模塊是同步的，這并不適合在瀏覽器環(huán)境，因?yàn)橥揭馕吨枞虞d，瀏覽器資源是異步加載的，因此有了AMD CMD解決方案。

AMD規(guī)范在瀏覽器環(huán)境中異步加載模塊，而且可以并行加載多個(gè)模塊。不過，AMD規(guī)范開發(fā)成本高，代碼的閱讀和書寫比較困難，模塊定義方式的語義不順暢。

CMD規(guī)范與AMD規(guī)范很相似，都用于瀏覽器編程，依賴就近，延遲執(zhí)行，可以很容易在Node.js中運(yùn)行。不過，依賴SPM 打包，模塊的加載邏輯偏重

ES6 在語言標(biāo)準(zhǔn)的層面上，實(shí)現(xiàn)了模塊功能，而且實(shí)現(xiàn)得相當(dāng)簡(jiǎn)單，完全可以取代 CommonJS 和 AMD 規(guī)范，成為瀏覽器和服務(wù)器通用的模塊解決方案。

花了很長(zhǎng)時(shí)間(>10h)終于把"JS模塊化"講清楚，自己對(duì)模塊化的認(rèn)識(shí)又加深了一步，事實(shí)上，理解一件事并不難，難的是如何將一件事通俗分享給別人，并讓別人也有所收獲，一直以來我也是這樣要求自己！文章如有錯(cuò)誤和不正之處，歡迎指正和批評(píng)，同時(shí)也希望大家多多支持，我會(huì)有更大的創(chuàng)作動(dòng)力!