CommonJS规范加载模块是同步的，也就是说，只有加载完成，才能执行后面的操作。AMD规范则是非同步加载模块，允许指定回调函数。由于Node.js主要用于服务器编程，模块文件一般都已经存在于本地硬盘，所以加载起来比较快，不用考虑非同步加载的方式，所以CommonJS规范比较适用。但是，如果是浏览器环境，要从服务器端加载模块，这时就必须采用非同步模式，因此浏览器端一般采用AMD规范。此外AMD规范比CommonJS规范在浏览器端实现要来着早。

定义暴露模块:

//定义没有依赖的模块
define(function(){
   return 模块
})

//定义有依赖的模块
define(["module1", "module2"], function(m1, m2){
   return 模块
})

引入使用模块:

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

通过比较两者的实现方法，来说明使用AMD规范的好处。

未使用AMD规范

// 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)

最后得到如下结果：

这种方式缺点很明显：首先会发送多个请求，其次引入的js文件顺序不能搞错，否则会报错！

使用require.js

RequireJS是一个工具库，主要用于客户端的模块管理。它的模块管理遵守AMD规范，RequireJS的基本思想是，通过define方法，将代码定义为模块；通过require方法，实现代码的模块加载。
接下来介绍AMD规范在浏览器实现的步骤：

官网: http://www.requirejs.cn/

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

然后将require.js导入项目: 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/", //基本路径 出发点在根目录下
    paths: {
      //映射: 模块标识名: 路径
      alerter: "./modules/alerter", //此处不能写成alerter.js,会报错
      dataService: "./modules/dataService"
    }
  })
  require(["alerter"], function(alerter) {
    alerter.showMsg()
  })
})()

// index.html文件


  
    
  
  
    
    
  

在index.html引入

此外在项目中如何引入第三方库？只需在上面代码的基础稍作修改：

// 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/", //基本路径 出发点在根目录下
    paths: {
      //自定义模块
      alerter: "./modules/alerter", //此处不能写成alerter.js,会报错
      dataService: "./modules/dataService",
      // 第三方库模块
      jquery: "./libs/jquery-1.10.1" //注意：写成jQuery会报错
    }
  })
  require(["alerter"], function(alerter) {
    alerter.showMsg()
  })
})()

上例是在alerter.js文件中引入jQuery第三方库，main.js文件也要有相应的路径配置。
小结：通过两者的比较，可以得出AMD模块定义的方法非常清晰，不会污染全局环境，能够清楚地显示依赖关系。AMD模式可以用于浏览器环境，并且允许非同步加载模块，也可以根据需要动态加载模块。

CMD规范专门用于浏览器端，模块的加载是异步的，模块使用时才会加载执行。CMD规范整合了CommonJS和AMD规范的特点。在 Sea.js 中，所有 JavaScript 模块都遵循 CMD模块定义规范。

定义暴露模块：

//定义没有依赖的模块
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()
})

官网: http://seajs.org/

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

然后将sea.js导入项目: 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) {
  //内部变量数据
  var data = "atguigu.com"
  //内部函数
  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()
})

最后得到结果如下：

ES6 模块的设计思想是尽量的静态化，使得编译时就能确定模块的依赖关系，以及输入和输出的变量。CommonJS 和 AMD 模块，都只能在运行时确定这些东西。比如，CommonJS 模块就是对象，输入时必须查找对象属性。

export命令用于规定模块的对外接口，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命令的时候，用户需要知道所要加载的变量名或函数名，否则无法加载。为了给用户提供方便，让他们不用阅读文档就能加载模块，就要用到export default命令，为模块指定默认输出。

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

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

模块默认输出, 其他模块加载该模块时，import命令可以为该匿名函数指定任意名字。

它们有两个重大差异：

① CommonJS 模块输出的是一个值的拷贝，ES6 模块输出的是值的引用。

② CommonJS 模块是运行时加载，ES6 模块是编译时输出接口。

第二个差异是因为 CommonJS 加载的是一个对象（即module.exports属性），该对象只有在脚本运行完才会生成。而 ES6 模块不是对象，它的对外接口只是一种静态定义，在代码静态解析阶段就会生成。

下面重点解释第一个差异，我们还是举上面那个CommonJS模块的加载机制例子:

// 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 模块的运行机制与 CommonJS 不一样。ES6 模块是动态引用，并且不会缓存值，模块里面的变量绑定其所在的模块。

简单来说就一句话：使用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 预设(将es6转换成es5的所有插件打包)

  {
    "presets": ["es2015"]
  }

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

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

//module3.js文件
// 默认暴露 可以暴露任意数据类项，暴露什么数据，接收到就是什么数据
export default () => {
  console.log("默认暴露")
}

// 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文件中引入

最后得到如下结果：

此外第三方库(以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规范主要用于服务端编程，加载模块是同步的，这并不适合在浏览器环境，因为同步意味着阻塞加载，浏览器资源是异步加载的，因此有了AMD CMD解决方案。

AMD规范在浏览器环境中异步加载模块，而且可以并行加载多个模块。不过，AMD规范开发成本高，代码的阅读和书写比较困难，模块定义方式的语义不顺畅。

CMD规范与AMD规范很相似，都用于浏览器编程，依赖就近，延迟执行，可以很容易在Node.js中运行。不过，依赖SPM 打包，模块的加载逻辑偏重

ES6 在语言标准的层面上，实现了模块功能，而且实现得相当简单，完全可以取代 CommonJS 和 AMD 规范，成为浏览器和服务器通用的模块解决方案。

花了很长时间(>10h)终于把"JS模块化"讲清楚，自己对模块化的认识又加深了一步，事实上，理解一件事并不难，难的是如何将一件事通俗分享给别人，并让别人也有所收获，一直以来我也是这样要求自己！文章如有错误和不正之处，欢迎指正和批评，同时也希望大家多多支持，我会有更大的创作动力!