插件兼容CommonJS, AMD, CMD 和 原生 JS

模塊標準

CommonJS

CommonJS 有三個全局變量 module、exports 和 require。可是因爲 AMD 也有 require 這個全局變量，故不使用這個變量來進行檢測。

若是想要對外提供接口的話，能夠將接口綁定到 exports （即 module.exports） 上。

function MyModule() { // ... } if(typeof module !== `undefined` && typeof exports === `object`) { module.exports = MyModule; }

CMD

CMD 規範中定義了 define 函數有一個公有屬性 define.cmd。

CMD 模塊中有兩種方式提供對外的接口，一種是 exports.MyModule = ...，一種是使用 return 進行返回。

AMD

AMD 規範中，define 函數一樣有一個公有屬性 define.amd。

AMD 中的參數即是這個模塊的依賴。那麼如何在 AMD 中提供接口呢？它是返回一個對象，這個對象就做爲這個模塊的接口，故咱們能夠這樣寫：

function MyModule() { // ... } if(typeof define === `function` && define.amd) { define(function() { return MyModule; }); }

總結

咱們除了提供 AMD 模塊接口，CMD 模塊接口，還得提供原生的 JS 接口。
因爲 CMD 和 AMD 均可以使用 return 來定義對外接口，故能夠合併成一句代碼。

一個直接能夠用的代碼以下：

;(function(){ function MyModule() { // ... } var moduleName = MyModule; if (typeof module !== 'undefined' && typeof exports === 'object') { module.exports = moduleName; } else if (typeof define === 'function' && (define.amd || define.cmd)) { define(function() { return moduleName; }); } else { this.moduleName = moduleName; } }).call(function() { return this || (typeof window !== 'undefined' ? window : global); });

另一種寫法：

/閉包執行一個當即定義的匿名函數
!function(factory) {

    //factory是一個函數，下面的koExports就是他的參數

    // Support three module loading scenarios
    if (typeof require === 'function' && typeof exports === 'object' && typeof module === 'object') {
        // [1] CommonJS/Node.js
        // [1] 支持在module.exports.abc,或者直接exports.abc
        var target = module['exports'] || exports; // module.exports is for Node.js
        factory(target);
    } else if (typeof define === 'function' && define['amd']) {
        // [2] AMD anonymous module
        // [2] AMD 規範 
        //define(['exports'],function(exports){
           //    exports.abc = function(){}
        //});
        define(['exports'], factory);
    } else {
        // [3] No module loader (plain <script> tag) - put directly in global namespace
        factory(window['ko'] = {});
    }
}(function(koExports){

    //ko的全局定義 koExports是undefined 對應着上面的[3] 這種狀況
    var ko = typeof koExports !== 'undefined' ? koExports : {};

    //定義一個ko的方法
    ko.abc = function(s){
        alert(s);
    }
});

//[3]中狀況的調用
ko.abc("msg");


兼容CommonJS和CMD(SeaJS)規範的。例子：

;(function(factory) {

// CommonJS/NodeJS
if(typeof require === 'function' && typeof exports === "object" && typeof module === "object") {
factory(require, exports, module);
}
// CMD/SeaJS
else if(typeof define === "function") {
define(factory);
}
// No module loader
else {
factory(function(){}, window['idcard']={}, {});
}

}(function(require, exports, module) {

 

// something...

 

exports.hello = function() {
return 'hello212';
}


}));

 

 

AMD、CMD、UMD 模塊的寫法

 

簡介

最近幾年，咱們能夠選擇的Javascript組件的生態系統一直在穩步增加。雖然陡增的選擇範圍是極好的，但當組件混合匹配使用時就會出現很尷尬的局面。開發新手們會很快發現不是全部組件都能彼此「和平相處」。

爲了解決這個問題，兩種競爭關係的模塊規範AMD和CommonJS問世了，它們容許開發者遵守一種約定的沙箱化和模塊化的方式來寫代碼，這樣就能避免「污染生態系統」。

AMD

隨着RequireJS成爲最流行的實現方式，異步模塊規範（AMD）在前端界已經被普遍認同。

下面是隻依賴jquery的模塊foo的代碼：

 

JavaScript

 

//    文件名: foo.js

define(['jquery'], function ($) {

    //    方法

    function myFunc(){};

 

    //    暴露公共方法

    return myFunc;

});

還有稍微複雜點的例子，下面的代碼依賴了多個組件而且暴露多個方法:

JavaScript

 

// 文件名: foo.js

define(['jquery', 'underscore'], function ($, _) {

// 方法

function a(){}; // 私有方法，由於沒有被返回(見下面)

function b(){}; // 公共方法，由於被返回了

function c(){}; // 公共方法，由於被返回了

     //    暴露公共方法

    return {

        b: b,

        c: c

    }

});

定義的第一個部分是一個依賴數組，第二個部分是回調函數，只有當依賴的組件可用時（像RequireJS這樣的腳本加載器會負責這一部分，包括找到文件路徑）回調函數才被執行。

注意，依賴組件和變量的順序是一一對應的（例如，jquery->$, underscore->_）。

同時注意，咱們能夠用任意的變量名來表示依賴組件。假如咱們把$改爲$$，在函數體裏面的全部對jQuery的引用都由$變成了$$。

還要注意，最重要的是你不能在回調函數外面引用變量$和_，由於它相對其它代碼是獨立的。這正是模塊化的目的所在！

CommonJS

若是你用Node寫過東西的話，你可能會熟悉CommonJS的風格（node使用的格式與之相差無幾）。由於有Browserify，它也一直被前端界普遍認同。

就像前面的格式同樣，下面是用CommonJS規範實現的foo模塊的寫法：

 

 

 

 

 

JavaScript

 

//    文件名: foo.js

//    依賴

var $ = require('jquery');

//    方法

function myFunc(){};

 

//    暴露公共方法（一個）

module.exports = myFunc;

還有更復雜的例子，下面的代碼依賴了多個組件而且暴露多個方法：

JavaScript

 

//    文件名: foo.js

var $ = require('jquery');

var _ = require('underscore');

 

//    methods

function a(){};    //    私有方法，由於它沒在module.exports中 (見下面)

function b(){};    //    公共方法，由於它在module.exports中定義了

function c(){};    //    公共方法，由於它在module.exports中定義了

 

//    暴露公共方法

module.exports = {

    b: b,

    c: c

};

 

UMD: 通用模塊規範

既然CommonJs和AMD風格同樣流行，彷佛缺乏一個統一的規範。因此人們產生了這樣的需求，但願有支持兩種風格的「通用」模式，因而通用模塊規範（UMD）誕生了。

不得不認可，這個模式略難看，可是它兼容了AMD和CommonJS，同時還支持老式的「全局」變量規範：

JavaScript

 

(function (root, factory) {

    if (typeof define === 'function' && define.amd) {

        // AMD

        define(['jquery'], factory);

    } else if (typeof exports === 'object') {

        // Node, CommonJS之類的

        module.exports = factory(require('jquery'));

    } else {

        // 瀏覽器全局變量(root 即 window)

        root.returnExports = factory(root.jQuery);

    }

}(this, function ($) {

    //    方法

    function myFunc(){};

 

    //    暴露公共方法

    return myFunc;

}));

保持跟上面例子同樣的模式，下面是更復雜的例子，它依賴了多個組件而且暴露多個方法:

JavaScript

 

(function (root, factory) {

    if (typeof define === 'function' && define.amd) {

        // AMD

        define(['jquery', 'underscore'], factory);

    } else if (typeof exports === 'object') {

        // Node, CommonJS之類的

        module.exports = factory(require('jquery'), require('underscore'));

    } else {

        // 瀏覽器全局變量(root 即 window)

        root.returnExports = factory(root.jQuery, root._);

    }

}(this, function ($, _) {

    //    方法

    function a(){};    //    私有方法，由於它沒被返回 (見下面)

    function b(){};    //    公共方法，由於被返回了

    function c(){};    //    公共方法，由於被返回了

 

    //    暴露公共方法

    return {

        b: b,

        c: c

    }

}));