浅谈AMD与CMD

AMD 是 RequireJS 在推广过程中对模块定义的规范化产出。

CMD 是 SeaJS 在推广过程中对模块定义的规范化产出。

这些规范的目的都是为了 JavaScript 的模块化开发，特别是在浏览器端的。
目前这些规范的实现都能达成浏览器端模块化开发的目的。

在了解AMD，CMD规范前，我们先来简单地了解下什么是模块？

简单的说，一个模块就是实现特定功能的文件，有了模块，我们就可以更方便地使用别人的代码，想要什么功能，就加载什么模块。当然，模块开发需要遵循一定的规范，否则各用各的就会乱套了。

目前，常用的JS模块规范主要有两种：CMD和AMD。
AMD
AMD，异步模块定义（Asynchronous Module Definition），它是依赖前置 (依赖必须一开始就写好)会先尽早地执行(依赖)模块。换句话说，所有的require都被提前执行（require 可以是全局或局部）。
AMD规范只定义了一个函数 define，它是全局变量。用法：

defind(id, dependencies, factory)

参数说明：

id：字符串类型，指定义中模块的名称，可选。如果没有提供该参数，模块的名称应该默认为模块加载器请求的指定脚本的名称。如果提供了该参数，模块名必须是“顶级”的和绝对的（不允许相对名称）。
dependencies：array类型，包含一组当前模块依赖的，已被模块定义的模块标识。

依赖参数是可选的，如果忽略此参数，它应该默认为["require", "exports", "module"]。然而，如果工厂方法的长度属性小于3，加载器会选择以函数的长度属性指定的参数个数调用工厂方法。

factory：函数（工厂方法），模块初始化要执行的函数或对象。如果为函数，它应该只被执行一次。如果是对象，此对象应该为模块的输出值。

模块名的格式
模块名用来唯一标识定义中模块，它们同样在依赖性数组中使用：

模块名是用正斜杠分割的有意义单词的字符串

单词须为驼峰形式，或者"."，".."

模块名不允许文件扩展名的形式，如“.js”

模块名可以为 "相对的" 或 "顶级的"。如果首字符为“.”或“..”则为相对的模块名

顶级的模块名从根命名空间的概念模块解析

相对的模块名从 "require" 书写和调用的模块解析

对于AMD，最具代表性的就是RequireJS，官网：www.requirejs.cn/。
简单实例：
首先在创建一个index.html，内容如下：

<!DOCTYPE html>

<head>

</head>

<body>

</body>

</html>

在上面的代码中，我们引入了require.js，然后使用data-main属性指定入口文件为scripts/main（这里省略后缀.js）。
然后在index.html同级下创建一个文件夹scripts，跟着创建三个js文件：a.js、b.js、mian.js，代码如下：

* a.js

* 创建一个名为“a”的模块

define('a', function(require, exports, module) {

exports.getTime = function() {

return new Date();

}

});

* b.js

* 创建一个名为“b”的模块，同时使用依赖require、exports和名为“a”的模块：

define('b', ['require', 'exports', 'a'], function(require, exports, a) { exports.test = function() {

return {

now: a.getTime()

};

}

});

/* main.js */

require(['b'], function(b) {

console.log(b.test());

});

关于Requirejs更多内容：www.requirejs.cn/home.html
CMD

CMD（Common Module Definition）更贴近 CommonJS Modules/1.1 和 Node Modules 规范，一个模块就是一个文件；它推崇依赖就近，想什么时候 require就什么时候加载，实现了懒加载（延迟执行）；它也没有全局 require，每个API都简单纯粹。

对于CMD，有代表性的是SeaJS，官网：seajs.org/docs/。
在 CMD 规范中，一个模块就是一个文件。代码的书写格式如下：

define(factory);

factory 为函数时，表示是模块的构造方法。执行该构造方法，可以得到模块向外提供的接口。factory 方法在执行时，默认会传入三个参数：require、exports 和 module：

define(function(require, exports, module) {

// 模块代码

});

简单实例：
创建一个index.html，内容如下：

<!DOCTYPE html>

<head>

</head>

<body>

/* 加载入口模块 */

seajs.use('./scripts/main');

</script>

</body>

</html>

然后在index.html同级下创建一个scripts文件夹，跟着创建两个js文件：a.js、main.js，代码如下：

* a.js

* 一个文件就是一个模块

define(function(require, exports, module) {

exports.getTime = function() {

return new Date();

}

});

/* main.js */

define(function(require, exports, module) {

/* 按需加载a.js */

var a = require('./a');

console.log(a.getTime());

});

RequireJS和Sea.js的共同点：

RequireJS 和 Sea.js 都是模块加载器

不同之处（出处：玉伯：与 RequireJS 的异同）：

定位有差异。RequireJS 想成为浏览器端的模块加载器，同时也想成为 Rhino / Node 等环境的模块加载器。Sea.js 则专注于 Web 浏览器端，同时通过 Node 扩展的方式可以很方便跑在 Node 环境中。
遵循的规范不同。RequireJS 遵循 AMD（异步模块定义）规范，Sea.js 遵循 CMD （通用模块定义）规范。规范的不同，导致了两者 API 不同。Sea.js 更贴近 CommonJS Modules/1.1 和 Node Modules 规范。
推广理念有差异。RequireJS 在尝试让第三方类库修改自身来支持 RequireJS，目前只有少数社区采纳。Sea.js 不强推，采用自主封装的方式来“海纳百川”，目前已有较成熟的封装策略。
对开发调试的支持有差异。Sea.js 非常关注代码的开发调试，有 nocache、debug 等用于调试的插件。RequireJS 无这方面的明显支持。
插件机制不同。RequireJS 采取的是在源码中预留接口的形式，插件类型比较单一。Sea.js 采取的是通用事件机制，插件类型更丰富。

AMD与CMD的比较

AMD：依赖前置，预执行（异步加载：依赖先执行）。CMD：依赖就近，懒（延迟）执行（运行到需加载，根据顺序执行）

// CMD
define(function(require, exports, module) {

var a = require('./a')

a.doSomething();

// 省略1万行

var b = require('./b') // 依赖可以就近书写

b.doSomething();

})

// AMD 默认推荐的是
define(['./a', './b'], function(a, b) { // 依赖必须一开始就写好

a.doSomething();

// 省略1万行

b.doSomething();

})

实例代码下载：实例
参考资料

前端模块规范有三种：CommonJs,AMD和CMD。
CommonJs用在服务器端，AMD和CMD用在浏览器环境
AMD 是 RequireJS 在推广过程中对模块定义的规范化产出。
CMD 是 SeaJS 在推广过程中对模块定义的规范化产出。
AMD:提前执行（异步加载：依赖先执行）+延迟执行
CMD:延迟执行（运行到需加载，根据顺序执行）

模块

函数写法

　　function f1(){

　　　　//...

　　}

　　function f2(){

　　　　//...

　　}

模块就是实现特定功能的文件，把几个函数放在一个文件里就构成了一个模块。需要的时候加载这个文件，调用其中的函数即可。
但这样做会污染全局变量，无法保证不与其他模块发生变量名冲突，而且模块成员之间没什么关系。

对象写法

      var module = {

　　　　star : 0,

　　　　f1 : function (){

　　　　　　//...

　　　　},

　　　　f2 : function (){

　　　　　　//...

　　　　}

　　};

      module.f1();

      module.star = 1;

模块写成一个对象，模块成员都封装在对象里，通过调用对象属性，访问使用模块成员。但同时也暴露了模块成员，外部可以修改模块内部状态。

立即执行函数

      var module = (function(){

　　　　var star = 0;

　　　　var f1 = function (){

　　　　　　console.log('ok');

　　　　};

　　　　var f2 = function (){

　　　　　　//...

　　　　};

         return {

            f1:f1,

            f2:f2

         };

　　})();

      module.f1();  //ok

      console.log(module.star)  //undefined

外部无法访问内部私有变量

CommonJs

CommonJS是服务器端模块的规范，由Node推广使用。由于服务端编程的复杂性，如果没有模块很难与操作系统及其他应用程序互动。使用方法如下：

math.js

exports.add = function() {

    var sum = 0, i = 0, args = arguments, l = args.length;

    while (i < l) {

      sum += args[i++];

    }

    return sum;

};

increment.js

var add = require('math').add;

exports.increment = function(val) {

    return add(val, 1);

};

index.js

var increment = require('increment').increment;

var a = increment(1); //2

根据CommonJS规范:

一个单独的文件就是一个模块。每一个模块都是一个单独的作用域，也就是说，在该模块内部定义的变量，无法被其他模块读取，除非定义为global对象的属性。
输出模块变量的最好方法是使用module.exports对象。
加载模块使用require方法，该方法读取一个文件并执行，返回文件内部的module.exports对象

仔细看上面的代码，您会注意到 require 是同步的。模块系统需要同步读取模块文件内容，并编译执行以得到模块接口。
然而，这在浏览器端问题多多。

浏览器端，加载 JavaScript 最佳、最容易的方式是在 document 中插入<script>标签。但脚本标签天生异步，传统 CommonJS 模块在浏览器环境中无法正常加载。

解决思路之一是，开发一个服务器端组件，对模块代码作静态分析，将模块与它的依赖列表一起返回给浏览器端。这很好使，但需要服务器安装额外的组件，并因此要调整一系列底层架构。

另一种解决思路是，用一套标准模板来封装模块定义：

define(function(require, exports, module) {

  // The module code goes here

});

这套模板代码为模块加载器提供了机会，使其能在模块代码执行之前，对模块代码进行静态分析，并动态生成依赖列表。

math.js

define(function(require, exports, module) {

  exports.add = function() {

    var sum = 0, i = 0, args = arguments, l = args.length;

    while (i < l) {

      sum += args[i++];

    }

    return sum;

  };

});

increment.js

define(function(require, exports, module) {

  var add = require('math').add;

  exports.increment = function(val) {

    return add(val, 1);

  };

});

index.js

define(function(require, exports, module) {

  var inc = require('increment').increment;

  inc(1); // 2

});

AMD

AMD是"Asynchronous Module Definition"的缩写，意思就是"异步模块定义"。由于不是JavaScript原生支持，使用AMD规范进行页面开发需要用到对应的库函数，也就是大名鼎鼎RequireJS，实际上AMD 是 RequireJS 在推广过程中对模块定义的规范化的产出

它采用异步方式加载模块，模块的加载不影响它后面语句的运行。所有依赖这个模块的语句，都定义在一个回调函数中，等到加载完成之后，这个回调函数才会运行。

RequireJS主要解决两个问题

多个js文件可能有依赖关系，被依赖的文件需要早于依赖它的文件加载到浏览器
js加载的时候浏览器会停止页面渲染，加载文件越多，页面失去响应时间越长

RequireJs也采用require()语句加载模块，但是不同于CommonJS，它要求两个参数:

第一个参数[module]，是一个数组，里面的成员就是要加载的模块；第二个参数callback，则是加载成功之后的回调函数。math.add()与math模块加载不是同步的，浏览器不会发生假死。

require([module], callback);

require([increment'], function (increment) {

　   increment.add(1);

});

define()函数

RequireJS定义了一个函数 define，它是全局变量，用来定义模块:
define(id?, dependencies?, factory);
参数说明：

id：指定义中模块的名字，可选；如果没有提供该参数，模块的名字应该默认为模块加载器请求的指定脚本的名字。如果提供了该参数，模块名必须是“顶级”的和绝对的（不允许相对名字）。
依赖dependencies：是一个当前模块依赖的，已被模块定义的模块标识的数组字面量。
依赖参数是可选的，如果忽略此参数，它应该默认为["require", "exports", "module"]。然而，如果工厂方法的长度属性小于3，加载器会选择以函数的长度属性指定的参数个数调用工厂方法。
工厂方法factory，模块初始化要执行的函数或对象。如果为函数，它应该只被执行一次。如果是对象，此对象应该为模块的输出值。

来举个