JavaScript--Module模式

//module: Module模式是JavaScript编程中一个非常通用的模式

window.onload = function() {
    //1、基本使用：
    var MyFn = function() {
        var age = 24,sex = "boy";//私有变量
        var action = function() {//私有行为
            console.log("it man");
        };
        return {//暴露的公开成员
            work : "orderMonkey",
            action2 : function() {
                console.log("it developer!");
            }
        }
    };
    var newMyFn = new MyFn();
    console.log(newMyFn.action2());
    console.log("===============================");
    //基本用法的缺点：每次使用时都要使用new 关键字生成，这样在内存中每次会copy一份，占用内存，使用闭包可以避免内存问题，实现自执行。也可以实现功能的扩展。

    //2、模块方法：
    var MyFn2 = (function() {
        var my = {};//向外返回的对象
        var age = 25,name = "assassin";
        var action = function() {
            console.log("内部私有成员");
        };
        my.EnglishName = "wanghf";
        my.action2 = function() {
            console.log("major in JavaScript!");
        };//公有代码状态
        return my;
        /*return my = {//向外返回的对象
         work : "It developer",
         action2 : function() {
         console.log("外部成员变量");
         }
         }*/
    })();
    console.log(MyFn2.action2());//调用时避免生成，减小内存占有量
    console.log("===============================");
    //模块方法全局变量的引入和jQuery设计思路一样采用全局传参
    var MyFn3 = (function($) {
        //同上
    })(jQuery);
    //3、模块的扩展：
    //对于大型项目测需要对自己的扩展了，基于上述的思想，同样把自己作为参数传值，进行扩展
    var MyFn2 = (function(my) {//var不是必写，为了统一。
        my.addName = "intelwisd";
        my.addAction3 = function() {
            console.log("扩展的新方法...");
        };
        /*var my1 = {
         addName : "intelwisd",
         addAction3 : function() {
         console.log("外部成员变量");
         }
         };*/ //对象的形式有对象的拷贝之前的会覆盖以前的
        return my;
    })(MyFn2);
    console.log(MyFn2.action2());
    console.log("===============================");
    //4、松耦合扩展和紧耦合扩展
    //松耦合扩展 利用 var MyFn2 = MyFn2 || {};
    var MyFn2 = (function(my) {
        my.addName1 = "intelwisd1";
        my.addAction4 = function() {
            console.log("松耦合扩展的新方法...");
        };
        /*var my = {
         addName: "intelwisd111",
         addAction3: function () {
         console.log("外部成员变量");
         }
         };*/
        return my;
    })(MyFn2 || {});
    console.log(MyFn2.EnglishName);
    console.log(MyFn2.addName1);
    console.log(MyFn2.action2());
    console.log(MyFn2.addAction4());
    //松耦合的优点：确保该对象，在存在的时候直接用，不存在的时候直接赋值为{}
    console.log("===============================");
    //紧耦合扩展 可以实现重载的功能，但要确保加载顺序
    var MyFn2 = (function(my) {
        var addAction4 = my.newAddAction4;
        my.newAddAction4 = function() {//重载函数，以前的函数可以继续使用
            console.log("紧耦合扩展....");
        };
        return my;
    })(MyFn2);
    console.log(MyFn2.addAction4());
    console.log(MyFn2.newAddAction4());
    console.log("===============================");
    //5、克隆与继承 （在紧耦合的基础上进行继承，其实该对象的属性对象或function根本没有被复制，只是对同一个对象多了一种引用而已，所以如果老对象去改变它，那克隆以后的对象所拥有的属性或function函数也会被改变。）
    var MyFn2 = (function(my) {
        var my1 = {}, key;
        for (key in my) {
            if (my.hasOwnProperty(key)) {
                my1[key] = my[key];
            }
        }
        var addAction4 = my1.newAddAction4;
        my1.newAddAction4 = function() {//重载函数，以前的函数可以继续使用
            console.log("紧耦合扩展2....");
            // 克隆以后，进行了重写，当然也可以继续调用以前的
        };
        return my1;
    })(MyFn2);
    console.log(MyFn2.addAction4());
    console.log(MyFn2.newAddAction4());
    console.log("===============================");
    //6、跨文件中的私有成员的共享
    var MyFn3 = (function (my) {
        var _private = my._private = my._private || {},
            _seal = my._seal = my._seal || function () {
                    delete my._private;
                    delete my._seal;
                    delete my._unseal;
                },
            _unseal = my._unseal = my._unseal || function () {
                    my._private = _private;
                    my._seal = _seal;
                    my._unseal = _unseal;
                };
        return my;
    } (MyFn2 || {}));
    //任何文件都可以对他们的局部变量_private设属性，并且设置对其他的文件也立即生效。一旦这个模块加载结束，应用会调用 blogModule._seal()"上锁"，这会阻止外部接入内部的_private。如果这个模块需要再次增生，应用的生命周期内，任何文件都可以调用_unseal() ”开锁”，然后再加载新文件。加载后再次调用 _seal()”上锁”。
    //子模块共有的成员创建
    MyFn2.CommentSubModule = (function () {
        var my = {};
        // ...

        return my;
    } ());
    //eg:
    MyFn3.CommentSubModule = (function () {
        var my = {
            name : "assassin",
            Fn1 : function() {
                alert(0);
            }
        };
        // ...

        return my;
    } ());
}

学习来源Tom大叔javascript--Module