module模式小记

当我们以一个通常的写法来写一个构造函数的时候（通过new 调用的函数） 它里面的属性和方法对外界是可见的

　　　　　function Person() {
            this.name = "haha";

            this.sayName = function(){
                return this.name;
            }

　　　　　　　return this;
        }

        var p1 = new Person();
        console.log(p1.sayName());//haha
        console.log(p1.name);//haha

　　　　　p1.name = ""ha";　　　　　console.log(p1.sayName());//ha

这里的Person定义了一个name属性和一个sayName方法 通过生成的对象能调用相应的方法 但是发现生成的对象也能直接调用name属性（这并没有任何奇怪 因为name本身就是生成对象的属性） 这样的模式不能达到我们实现私有属性的目的

要实现私有属性 ，就要通过匿名闭包

(function(){
            //所用的变量和function都在这里声明，作用域也只能存在这个闭包中，这里的代码仍然能访问外部的作用域，是作用链的问题

        }());

我们在匿名闭包中声明变量和function 这样作用域只存在这个闭包中，外界无法访问 ，但是这里的代码可以通过作用链查找到外面的变量

下面我们来实现一个简单的例子（简单的module模式）

var module = (function(){
            var my = {},
                id = 123;

            function getId() {
                return id;
            }//私有变量和function在这里声明，在外边是不能访问到的

            my.Id = id;
            my.getPrivateId = function() {
                return getId();
            }

            return my; //只能通过返回的my来访问内部的私有变量和function
        }());

        console.log(module.Id);
        console.log(module.getPrivateId());　　　

当我们有新的需求要扩展我们的module的时候（项目组的好几个人都要扩展） 首先他要引入之前的module文件 也就是上面这段例子，然后在进行扩展（这样也实现了module的多人开发）

var module = (function(my){
            my.say = function() {
                return "扩展了";
            }

            return my;
        }(module));

        console.log(module.say()); //扩展了

这里实现的方式是将之前的module传入匿名闭包函数 ，对它的相应的功能进行添加，同时还是保持了之前私有变量和function的私有性,这里的var并不是必须的（因为之前已经声明了module 这是一种紧耦合的扩展模式），这种模式对文件的加载顺序有要求

如果不对文件的加载顺序有要求，也就是松耦合的扩展模式 可以这样实现

var module = (function(my){
            //扩展

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

当我们为匿名闭包传递参数的时候传递的是 module || {} 也就是当module不存在的时候 ，我们去创建它 这就不需要我们文件的加载顺序有要求了，这是一种松耦合的扩展模式，这种模式下也有一定的限制，就是不能重写一些属性和方法 （因为不用加载顺序，当我们想重写的时候，相应的属性和方法有可能不存在，就不存的重写这个说法，也就是新的定义）并且这里的var必须写，（因为其他的人想读取你的文件的时候会读取不到）

紧耦合的模式下虽然限制了加载的顺序，但是能提供给我们重写属性方法的机会

var module = (function(){
            var my = {};
            var id = 123;
            function a() {
                return "a";
            };

            my.b = function(){
                return "this is old func";
            }
            return my;
        }());
        console.log(module.b());//this is old func
        var module = (function(my){
            var oldfunc = my.b;

            my.b = function() {
                return "this is new func";
            }
            my.oldfunc = oldfunc;
            return my;
        }(module));

        console.log(module.b()); //this is new func
        console.log(module.oldfunc());//this is old func

上面是一个完成了例子 重写了之前定义的b方法 并且通过将之前的方法重新添加到module中，也可以访问之前的方法

子模块实现方式 当我们需求在上面的module下实现一个子模块的时候 我们可以这样

module.test = (function(){
            var name = "aa",
                my = {};

            my.sayName = function(){　　　　　　　　　//console.log(mudule.b()); //子模块能调用父模块的方法 他们在一个命名空间
                return name;
            }

            return my;
        }());

        console.log(module.test.sayName());//aa

这样就实现了一个子模块

在javascript设计模式的书中，提供了一种创建命名空间的方式，上面的创建子模块的方式 子模块和父模块存在一个命名空间（有些时候我们想要实现的是两个module存在不同的命名空间 ） 下面给出书中的实现方式

首先我们需要一个创建命名空间的通用函数

　　　　var MySpace = MySpace || {};
        MySpace.namespace = function(ns_string){
            var parts = ns_string.split(‘.‘),
                parent = MySpace,
                i = 0,
                length = 0;

            if(parts[0] === "MySpace") {
                parts = parts.slice(1);
            }

            for(i = 0;length = parts.length,i < length;i += 1) {
                if(typeof parent[parts[i]] === "undefined") {
                    parent[parts[i]] = {};
                }

                parent = parent[parts[i]];
            }

            return parent;

        }

通过上面的函数我们就能在相应的命名空间里创建我们的module了

MySpace.namespace(‘MySpace.modules.test‘);

        MySpace.modules.test = (function(){
            var name = "haha",
                my = {};

            my.sayName = function(){
                return  name;
            }

            return my;
        }());

MySpace.namespace(‘MySpace.modules.a‘);//在同样的层级创建其他的module

参考 javascript设计模式

blog http://www.cnblogs.com/TomXu/archive/2011/12/30/2288372.html