模块

【示例】：

function CoolModule() {
    var something = "cool",
        another = [1, 2, 3];
        
    function doSomething() {
        console.log(something);
    }
    
    function doAnother() {
        console.log(another.join(" ! "));
    }
    
    return {
        doSomething: doSomething,
        doAnother: doAnother
    };
}

var foo = CoolModule();

foo.doSomething(); // cool
foo.doAnother(); // 1 ! 2 ! 3

【解释】：

• 这个模式在 JavaScript 中被称为模块。最常见的实现模块模式的方法通常被称为模块暴露，这里展示的是其变体。
• 首先，CoolModule() 只是一个函数，必须要通过调用它来创建一个模块实例。如果不执行外部函数，内部作用域和闭包都无法被创建。
• 其次，CoolModule() 返回一个用对象字面量语法 { key: value, ... } 来表示的对象。这个返回的对象中含有对内部函数而不是内部数据变量的引用。我们保持内部数据变量是隐藏且私有的状态。可以将这个对象类型的返回值看作本质上模块的公共 API。
• 这个对象类型的返回值最终被赋值给外部的变量 foo，然后就可以通过它来访问 API 中的属性方法。

【注意】：从模块中返回一个实际的对象并不是必须的，也可以直接返回一个内部函数，例如 jQuery（jQuery 和 $ 标识符就是 jQuery 模块的公共 API，但它们本身都是函数）。

【模块模式需要具备的两个必要条件】：

1. 必须有外部的封闭函数，该函数必须至少被调用一次。
2. 封闭函数必须返回至少一个内部函数，这样内部函数才能在私有作用域中形成闭包，并且可以访问或者修改私有的状态。

【注意】：一个具有函数属性的对象本身并不是真正的模块。换言之，一个从函数调用所返回的，只有数据属性而没有闭包函数的对象并不是真正的模块。

【示例】：改进-单例模式

var foo = (function CoolModule() {
    var something = "cool",
        another = [1, 2, 3];
        
    function doSomething() {
        console.log(something);
    }
    
    function doAnother() {
        console.log(another.join(" ! "));
    }
    
    return {
        doSomething: doSomething,
        doAnother: doAnother
    };
})();

foo.doSomething(); // cool
foo.doAnother(); // 1 ! 2 ! 3

【解释】：将模块函数转换成了 IIFE，立即调用这个函数并将返回值直接赋值给单例的模块实例标识符 foo。

【提示】：模块也是普通的函数，因此也可以接受参数。

【用法】：命名将要作为公共 API 返回的对象。

var foo = (function CoolModule(id) {
    function change() {
        // 修改公共 API
        publicAPI.identify = identify2;
    }
    
    function identify1() {
        console.log(id);
    }
    
    function identify2() {
        console.log(id.toUpperCase());
    }
    
    var publicAPI = {
        change: change,
        identify: identify1
    };
    
    return publicAPI;
})("foo module");

foo.identify(); // foo module
foo.change();
foo.identify(); //FOO MODULE

【解释】：通过在模块实例的内部保留对公共 API 对象的内部引用，可以从内部对模块实例进行修改，包括添加或删除方法和属性，以及修改它们的值。

现代的模块机制

大多数模块依赖加载器/管理器本质上都是将这种模块定义封装进一个友好的 API。

【示例】：

var MyModules = (function Manager() {
    var modules = {};
    
    function define(name, deps, impl) {
        for(var i = 0; i < deps.length; i++) {
            deps[i] = modules[deps[i]];
        }
        modules[name] = impl.apply(impl, deps);
    }
    
    function get(name) {
        return modules[name];
    }
    
    return {
        define: define,
        get: get
    };
})();

MyModules.define("bar", [], function() {
    function hello(who) {
        return "Let me introduce: " + who;
    }
    
    return {
        hello: hello
    };
});

MyModules.defind("foo", ["bar"], function(bar) {
    var hungry = "hippo";
    
    function awesome() {
        console.log(bar.hello(hungry).toUpperCase());
    }
    
    return {
        awesome: awesome
    };
});

var bar = MyModules.get("bar");
var foo = MyModules.get("foo");

console.log(bar.hello("hippo"));
foo.awesome();

未来的模块机制

ES6 中为模块增加了一级语法支持。在通过模块系统进行加载时，ES6 会将文件当作独立的模块来处理。每个模块都可以导入其他模块或特定的 API 成员，同样也可以导出自己的 API 成员。

详细内容请参考 ES6 模块机制。

小结

• 模块有两个主要特征：（1）为创建内部作用域而调用了一个包装函数；（2）包装函数的返回值必须至少包括一个对内部函数的引用，这样就会创建涵盖整个包装函数内部作用域的闭包。