*近几年，我们可以选择的Javascript组件的生态系统一直在稳步增长。虽然陡增的选择范围是*好的，但当组件混合匹配使用时就会出现很尴尬的局面。开发新手们会很快发现不是所有组件都能彼此“和平相处”。

为了解决这个问题，两种竞争关系的模块规范AMD和CommonJS问世了，它们允许开发者遵照一种约定的沙箱化和模块化的方式来写代码，这样就能避免“污染生态系统”。

AMD

随着RequireJS成为*流行的实现方式，异步模块规范（AMD）在前端界已经被广泛认同。

下面是只依赖jquery的模块foo的代码：

  1. // 文件名: foo.js
  2. define([“jquery”], function ($) {
  3. // 方法
  4. function myFunc(){};
  6. // 暴露公共方法
  7. return myFunc;
  8. });

还有稍微复杂点的例子，下面的代码依赖了多个组件并且暴露多个方法:

  1. // 文件名: foo.js
  2. define([“jquery”, “underscore”], function ($, _) {
  3. // 方法
  4. function a(){}; // 私有方法，因为没有被返回(见下面)
  5. function b(){}; // 公共方法，因为被返回了
  6. function c(){}; // 公共方法，因为被返回了
  8. // 暴露公共方法
  9. return {
  10. b: b,
  11. c: c
  12. }
  13. });

定义的*个部分是一个依赖数组，第二个部分是回调函数，只有当依赖的组件可用时（像RequireJS这样的脚本加载器会负责这一部分，包括找到文件路径）回调函数才被执行。

注意，依赖组件和变量的顺序是一一对应的（例如，jquery->$, underscore->_）。

同时注意，我们可以用任意的变量名来表示依赖组件。假如我们把$改成

，在函数体里面的所有对jQuery的引用都由$变成了，在函数体里面的所有对jQuery的引用都由$变成了

。还要注意，*重要的是你不能在回调函数外面引用变量$和_，因为它相对其它代码是独立的。这正是模块化的目的所在！

CommonJS

如果你用Node写过东西的话，你可能会熟悉CommonJS的风格（node使用的格式与之相差无几）。因为有Browserify，它也一直被前端界广泛认同。

就像前面的格式一样，下面是用CommonJS规范实现的foo模块的写法：

  1. // 文件名: foo.js
  2. // 依赖
  3. var $ = require(“jquery”);
  4. // 方法
  5. function myFunc(){};
  7. // 暴露公共方法（一个）
  8. module.exports = myFunc;

还有更复杂的例子，下面的代码依赖了多个组件并且暴露多个方法：

  1. // 文件名: foo.js
  2. var $ = require(“jquery”);
  3. var _ = require(“underscore”);
  5. // methods
  6. function a(){}; // 私有方法，因为它没在module.exports中 (见下面)
  7. function b(){}; // 公共方法，因为它在module.exports中定义了
  8. function c(){}; // 公共方法，因为它在module.exports中定义了
  10. // 暴露公共方法
  11. module.exports = {
  12. b: b,
  13. c: c
  14. };

AMD与CMD的区别

CMD相当于按需加载，定义一个模块的时候不需要立即制定依赖模块，在需要的时候require就可以了，比较方便；而AMD则相反，定义模块的时候需要制定依赖模块，并以形参的方式引入factory中。

UMD: 通用模块规范

既然CommonJs和AMD风格一样流行，似乎缺少一个统一的规范。所以人们产生了这样的需求，希望有支持两种风格的“通用”模式，于是通用模块规范（UMD）诞生了。

不得不承认，这个模式略难看，但是它兼容了AMD和CommonJS，同时还支持老式的“全局”变量规范：

  1. (function (root, factory) {
  2. if (typeof define === “function” && define.amd) {
  3. // AMD
  4. define([“jquery”], factory);
  5. } else if (typeof exports === “object”) {
  6. // Node, CommonJS之类的
  7. module.exports = factory(require(“jquery”));
  8. } else {
  9. // 浏览器全局变量(root 即 window)
  10. root.returnExports = factory(root.jQuery);
  11. }
  12. }(this, function ($) {
  13. // 方法
  14. function myFunc(){};
  16. // 暴露公共方法
  17. return myFunc;
  18. }));
注：echarts中的中国地图china.js就采用的这种方式。

保持跟上面例子一样的模式，下面是更复杂的例子，它依赖了多个组件并且暴露多个方法:

  1. (function (root, factory) {
  2. if (typeof define === “function” && define.amd) {
  3. // AMD
  4. define([“jquery”, “underscore”], factory);
  5. } else if (typeof exports === “object”) {
  6. // Node, CommonJS之类的
  7. module.exports = factory(require(“jquery”), require(“underscore”));
  8. } else {
  9. // 浏览器全局变量(root 即 window)
  10. root.returnExports = factory(root.jQuery, root._);
  11. }
  12. }(this, function ($, _) {
  13. // 方法
  14. function a(){}; // 私有方法，因为它没被返回 (见下面)
  15. function b(){}; // 公共方法，因为被返回了
  16. function c(){}; // 公共方法，因为被返回了
  18. // 暴露公共方法
  19. return {
  20. b: b,
  21. c: c
  22. }
  23. }));