js 模块模式

var module=(function(){
    var name="张三",
            age=10;
    function alt(){
        alert(age);
    };
    var my={
        num:function(){
            return alt();
        },
        getName:function(){
            return name;
        }
    };
    return my;
})();
       //扩充模块
       var module=(function(my){//匿名参数就是上一个module
           var num=20;
           my.getNum=function(){
               alert(num);
           };
           return my;
       })(module);

       //松耦合扩充每个文件如下结构
       var module=(function(my){
           var num=20;
           my.getNum=function(){
               alert(num);
           };
           return my;
       })(module||{});
//松耦合不能安全的覆写模块属性（因为没有加载循序），
       // 紧耦合扩充意味着一组加载顺序，但是允许覆写。
       var module=(function(my){
           var odlenum=my.num;
           my.num=function(){
                alert(100);
           };
           my.getNum=function(){
               alert(num);
           };
           return my;
       })(module);
        alert(module.getName());
        //克隆
       var MODULE_TWO = (function (old) {
           var my = {},
                   key;

           for (key in old) {
               if (old.hasOwnProperty(key)) {
                   my[key] = old[key];
               }
           }
           var super_moduleMethod = old.moduleMethod;
           my.moduleMethod = function () {
               // 此时super_moduleMethod就保存了父级 moduleMethod;

           };
           return my;
       }(module));

        /*跨文件私有状态
         一个模块分割成几个文件有一个严重缺陷。
         每个文件都有自身的私有状态，
         且无权访问别的文件的私有状态。
         这可以修复的。下面是一个松耦合扩充的例子，
         不同扩充文件之间保持了私有状态：*/
       var MODULE = (function (my) {
           var _private = my._private = my._private || {},
                   _seal = my._seal = my._seal || function () {//必须通过此方法来添加扩展Module文件
                               delete my._private;
                               delete my._seal;
                               delete my._unseal;
                           },//模块加载后，调用以移除对_private的访问权限
                   _unseal = my._unseal = my._unseal || function () {
                               my._private = _private;
                               my._seal = _seal;
                               my._unseal = _unseal;
                           };//模块加载前，开启对_private的访问，以实现扩充部分对私有内容的操作
                             //异步调用

           // 永久获得 _private, _seal, and _unseal

           return my;
       }(module|| {}));


       //子模块

       MODULE.sub = (function () {
           var my = {};
           // 就是多一级命名空间

           return my;
       }());
        /*大多数高级模式可以互相组合成更多有用的模式。如果要我提出一个复杂应用的设计模式，
        我会组合松耦合、私有状态和子模块。
         这里我还没有涉及性能，不过我有个小建议：
         模块模式是性能增益的。他简化了许多，加快代码下载。
         松耦合可以无阻塞并行下载，等价于提高下载速度。可能初始化比别的方法慢一点，
         但值得权衡。只要全局正确的引入，运行性能不会有任何损失，
         可能还因为局部变量和更少的引用，加快子模块的加载。
         最后，一个例子动态加载子模块到父模块（动态创建）中。
         这里就不用私有状态了，其实加上也很简单。这段代码允许整个复杂分成的代码核
         心及其子模块等平行加载完全。*/

       var UTIL = (function (parent, $) {
           var my = parent.ajax = parent.ajax || {};

           my.get = function (url, params, callback) {
               // ok, so I'm cheating a bit :)
               return $.getJSON(url, params, callback);
           };
           // etc...
           return parent;
       }(UTIL || {}, jQuery));