CMD&seaJS

本文主要摘自：https://github.com/seajs/seaj...
还有一篇文章可以参考：https://segmentfault.com/a/11...

使用seaJS

在 Sea.js 中，所有 JavaScript 模块都遵循 CMD（Common Module Definition）模块定义规范。该规范明确了模块的基本书写格式和基本交互规则。
开始使用sea.js:


    <script type="text/javascript" src="./sea.js"></script>
    <script type="text/javascript">
        
    seajs.use('./main.js');
        
    </script>

A同事写的main.js:

    define(function (require,exports,module) {
        var oInput = document.getElementById('input1');
        var oDiv1 = document.getElementById('div1');
        var oDiv2 = document.getElementById('div2');
        var oDiv3 = document.getElementById('div3');
    
        require('./drag.js').drag(oDiv3);//就近依赖，注意区别AMD的main.js
        oInput.onclick = function () {
            oDiv1.style.display = 'block';
            require('./scale.js').scale(oDiv1,oDiv2);
    
            require.async('./scale.js', function (ex) {
                ex.scale(oDiv1,oDiv2);
            })
        }
    });

编写CMD模块

在 CMD 规范中，一个模块就是一个文件。代码的书写格式如下：

    define(factory);

define 是一个全局函数，用来定义模块。

define(factory)

define 接受 factory 参数，factory 可以是一个函数，也可以是一个对象或字符串。

factory 为对象、字符串时，表示模块的接口就是该对象、字符串。

比如可以如下定义一个 JSON 数据模块：

define({ "foo": "bar" });

也可以通过字符串定义模板模块：

define('I am a template. My name is {{name}}.');

factory 为函数时，表示是模块的构造方法。

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

    define(function(require, exports, module) {
    
      // 模块代码
    
    });
    
    define define(id?, deps?, factory)

define.cmd Object
一个空对象，可用来判定当前页面是否有 CMD 模块加载器：

if (typeof define === "function" && define.cmd) {
  // 有 Sea.js 等 CMD 模块加载器存在
}

require

Function 类型
require 是 factory 函数的第一个参数:
require(id)
require 是一个方法，接受模块标识作为唯一参数，用来获取其他模块提供的接口。

    define(function(require, exports) {
    
      // 获取模块 a 的接口
      var a = require('./a');
    
      // 调用模块 a 的方法
      a.doSomething();
    
    });

注意：在开发时，require 的书写需要遵循一些简单约定。

    require.async require.async(id, callback?)

require.async
require.async方法用来在模块内部异步加载模块，并在加载完成后执行指定回调。callback 参数可选。

    define(function(require, exports, module) {
    
      // 异步加载一个模块，在加载完成时，执行回调
      require.async('./b', function(b) {
        b.doSomething();
      });
    
      // 异步加载多个模块，在加载完成时，执行回调
      require.async(['./c', './d'], function(c, d) {
        c.doSomething();
        d.doSomething();
      });
    
    });

注意：require 是同步往下执行，require.async 则是异步回调执行。require.async 一般用来加载可延迟异步加载的模块。

require.resolve(id)

使用模块系统内部的路径解析机制来解析并返回模块路径。该函数不会加载模块，只返回解析后的绝对路径。

define(function(require, exports) {

  console.log(require.resolve('./b'));
  // ==> http://example.com/path/to/b.js

});

这可以用来获取模块路径，一般用在插件环境或需动态拼接模块路径的场景下。

exports

exports 是一个对象，用来向外提供模块接口。

    define(function(require, exports) {
    
      // 对外提供 foo 属性
      exports.foo = 'bar';
    
      // 对外提供 doSomething 方法
      exports.doSomething = function() {};
    
    });

除了给 exports 对象增加成员，还可以使用 return 直接向外提供接口。

    define(function(require) {
    
      // 通过 return 直接提供接口
      return {
        foo: 'bar',
        doSomething: function() {}
      };
    
    });

如果 return 语句是模块中的唯一代码，还可简化为：

    define({
      foo: 'bar',
      doSomething: function() {}
    });

上面这种格式特别适合定义 JSONP 模块。
特别注意：下面这种写法是错误的！

    define(function(require, exports) {
    
      // 错误用法！！!
      exports = {
        foo: 'bar',
        doSomething: function() {}
      };
    
    });

正确的写法是用 return 或者给 module.exports 赋值：

    define(function(require, exports, module) {
    
      // 正确写法
      module.exports = {
        foo: 'bar',
        doSomething: function() {}
      };
    
    });

提示：exports 仅仅是 module.exports 的一个引用。在 factory 内部给 exports 重新赋值时，并不会改变 module.exports 的值。因此给 exports 赋值是无效的，不能用来更改模块接口。

module

module 是一个对象，上面存储了与当前模块相关联的一些属性和方法。
module.id
String类型

模块的唯一标识。

define('id', [], function(require, exports, module) {

  // 模块代码

});

上面代码中，define 的第一个参数就是模块标识。
module.uri
String类型

根据模块系统的路径解析规则得到的模块绝对路径。

    define(function(require, exports, module) {
    
      console.log(module.uri); 
      // ==> http://example.com/path/to/this/file.js
    
    });

一般情况下（没有在 define 中手写 id 参数时），module.id 的值就是 module.uri，两者完全相同。
module.dependencies
Array类型
dependencies 是一个数组，表示当前模块的依赖。
module.exports
Object类型
当前模块对外提供的接口。
传给 factory 构造方法的 exports 参数是 module.exports 对象的一个引用。只通过 exports 参数来提供接口，有时无法满足开发者的所有需求。比如当模块的接口是某个类的实例时，需要通过 module.exports 来实现：

    define(function(require, exports, module) {
    
      // exports 是 module.exports 的一个引用
      console.log(module.exports === exports); // true
    
      // 重新给 module.exports 赋值
      module.exports = new SomeClass();
    
      // exports 不再等于 module.exports
      console.log(module.exports === exports); // false
    
    });

注意：对 module.exports 的赋值需要同步执行，不能放在回调函数里。下面这样是不行的：

    // x.js
    define(function(require, exports, module) {
    
      // 错误用法
      setTimeout(function() {
        module.exports = { a: "hello" };
      }, 0);
    
    });

在 y.js 里有调用到上面的 x.js:

    // y.js
    define(function(require, exports, module) {
    
      var x = require('./x');
    
      // 无法立刻得到模块 x 的属性 a
      console.log(x.a); // undefined
    
    });

define(id?, dependencies?, factory)

define 也可以接受两个以上参数。字符串 id 表示模块标识，数组 deps 是模块依赖。比如：

    define('hello', ['jquery'], function(require, exports, module) {
    
      // 模块代码
    
    });

id 和 deps 参数可以省略。省略时，可以通过构建工具自动生成。

注意：带 id 和 deps 参数的 define 用法不属于 CMD 规范，而属于 Modules/Transport 规范。

id：模块标识
dependencies 是一个数组，表示当前模块的依赖。

RequireJS和SeaJS

RequireJS由James Burke创建，他也是AMD规范的创始人。
define方法用于定义模块，RequireJS要求每个模块放在一个单独的文件里。
相同之处:
RequireJS 和 Sea.js 都是模块加载器，倡导模块化开发理念，核心价值是让 JavaScript 的模块化开发变得简单自然。
不同之处:
AMD 是 RequireJS 在推广过程中对模块定义的规范化产出。
CMD 是 SeaJS 在推广过程中对模块定义的规范化产出。
类似的还有 CommonJS Modules/2.0 规范，是 BravoJS 在推广过程中对模块定义的规范化产出。
这些规范的目的都是为了 JavaScript 的模块化开发，特别是在浏览器端的。
目前这些规范的实现都能达成浏览器端模块化开发的目的。

链接：http://www.zhihu.com/question...
AMD 规范在这里：https://github.com/amdjs/amdj...
CMD 规范在这里：https://github.com/seajs/seaj...

两者的主要区别如下：

对于依赖的模块，AMD 是提前执行，CMD 是延迟执行。

不过 RequireJS 从 2.0 开始，也改成可以延迟执行（根据写法不同，处理方式不同）。CMD 推崇 as lazy as possible.

CMD 推崇依赖就近，AMD 推崇依赖前置。
看代码：

    // CMD
    define(function(require, exports, module) {
    var a = require('./a')
    a.doSomething()
    // ...
    var b = require('./b') // 依赖可以就近书写
    b.doSomething()
    // ...
    })
    
    // AMD 默认推荐的是
    define(['./a', './b'], function(a, b) { // 依赖必须一开始就全部写好
    a.doSomething()
    // ...
    b.doSomething()
    ...
    })

虽然 AMD 也支持 CMD 的写法，同时还支持将 require 作为依赖项传递，但 RequireJS 的作者默认是最喜欢上面的写法，也是官方文档里默认的模块定义写法。

AMD 的 API 默认是一个当多个用，CMD 的 API 严格区分，推崇职责单一。

比如 AMD 里，require 分全局 require 和局部 require，都叫 require。
CMD 里，没有全局 require，而是根据模块系统的完备性，提供 seajs.use 来实现模块系统的加载启动。CMD 里，每个 API 都简单纯粹。

还有一些细节差异，具体看这个规范的定义就好，就不多说了。

另外，SeaJS 和 RequireJS 的差异，可以参考：https://github.com/seajs/seaj...
SeaJS与RequireJS最大的区别:
SeaJS对模块的态度是懒执行, 而RequireJS对模块的态度是预执行。
不明白？看这篇图文并茂的文章吧：http://www.douban.com/note/28...
总之，如果说 RequireJS 是 Prototype 类库的话，则 Sea.js 致力于成为 jQuery 类库。

小结

这就是 CMD 模块定义规范的所有内容。经常使用的 API 只有 define, require, require.async, exports, module.exports 这五个。其他 API 有个印象就好，在需要时再来查文档，不用刻意去记。

与 RequireJS 的 AMD 规范相比，CMD 规范尽量保持简单，并与 CommonJS 和 Node.js 的 Modules 规范保持了很大的兼容性。