教你如何写模块（循序渐进）

写法一：函数即模块

function mod1(){
    //the code of mod1
}
function mod2(){
    //the code of mod2
}
//调用模块1
mod1();
//调用模块2
mod2();

优点：简单易懂
缺点：每个函数都是全局的，太多全局变量，容易代码冲突
结论：只能放弃

写法二：对象写法

为解决方法一造成很多全局变量的问题，决定将mod1和mod2放在一个对象里

var module1 = new Object({
    _count: 5,
    func1: function(){
        //the code of func1
    },
    func2: function(){
        //the code of func2
    }
});
//调用
module1.func1();
//弊端是对象里面的所有成员都会暴露在外面，可以被修改，比如_count
module1._count = 2;

优点：减少了全局变量，代码更加好管理
缺点：模块里面所有的成员都是对外暴露的，很多时候我们并不是这么想的，我们希望私有变量的存在
结论：同样只能放弃

写法三：Immediately-invoked Function Expression, IIFE（立即函数写法）

var module1 = (function(){
    var _count = 5;
    var func1 = function(){
        //the code of func1
    };
    var func2 = function(){
        //the code of func2q
    };
    //暴露要对外的接口
    return {
        func1: func1,
        func2: func2
    }
})();

//以上写法，外部是无法访问到_count变量的
console.log(module1._count);    //undefined

优点：满足了模块的封装，有很好地控制了模块内部成员的访问权限
缺点：当一个模块很大，需要分成几部分，或者一个模块需要继承另外一个模块时，无法满足
结论：进行稍加优化改造即可

改造一：放大模式

核心：将模块作为参数传进来，在“模块拓建”完成后再返回

//此时需要给module1添加一个方法三
var module1 = (function(mod){
    //添加func3代码
    mod.func3 = function(){
        //code of func3
    };
    
    return mod;
})(module1);

缺点：在浏览器环境中，模块的各个部分很可能都是从网上获取的，哪个部分先加载完可能我们不是很清楚，所以有可能加载到一个不存在空对象。

改造二： 宽放大模式

为了避免加载到一个不存在的空对象，采用以下写法
文件a.js->存放module1的部分代码

var module1 = (function(mod){
    var _count = 0;
    mod.func1 = function(){
        //code of func1
    };

    return mod;
})(window.module1 || {});

文件b.js->存放module1的另外一部分代码

var module1 = (function(mod){
    mod.func2 = function(){
        //code of func2
    };
    
    return mod;
})(module1);

这样就不用担心a.js和b.js哪个先加载完哪个慢加载完了，模块代码都不会丢失了。

引入全局变量

模块的一大特性是独立，模块内部代码最好不要和程序的其他部分直接交互，这样能够降低模块和其他部分代码的耦合性。
当需要在模块内调用其他变量，需要将其他全局变量输入模块

var module1 = (function(mod, $){
    var _count = 5;
    mod.renderDom = function(){
        $('cnt').html('<p>just try!</p>');
    };
})(window.module1 || {}, jQuery);

完