JS面向对象程序设计之创建对象模式

一、工厂模式

function createPerson(name,age,job){
    var o=new Object();
    o.name=name;
    o.age=age;
    o.job=job;
    o.sayName=fucntion(){
        alert(this.name);
    };
    return o;
}

var person1=createPerson("Nicholas",29,"Software Engineer");
var person2=createPerson("Greg",27,"Doctor");

优点：
抽象了创建具体对象的过程，解决了创建多个相似对象的问题
缺点：
没有解决对象识别的问题（即怎样知道一个对象的类型）

二、构造函数模式

function Person(name ,age,job){
    this.name=name;
    this.age=age;
    this.job=job;
    this.sayName=function(){
        alert(this.name);
    };
}

var person1=new Person("Nicholas",29,"Software Engineer");
var person2=new Person("Greg",27,"Doctor");

构造函数始终都应该以一个大写字母开头，而非构造函数则应该以一个小写字母开头。任何函数，只要通过new操作符来调用，那它就可以作为构造函数，而任何函数，如果不通过new操作符来调用，那它跟普通函数也不会有什么两样。

构造函数模式的优点：
解决了对象识别的问题：Person1和Person2分别保存着Person的一个不同的实例。这两个对象又有一个constructor(构造函数)属性，该属性指向Person,如下所示：

alert(person1.constructor==Person); //true
alert(person2.constructor==Person); //true

构造函数模式的缺点:
每个方法都要在每个实例上重新创建一遍。以这种方式创建函数，会导致不同的作用域链和标识符解析，但创建Function新实例的机制仍然是相同的，然而创建两个完成同样任务的Function实例是没有必要的。

三、原型模式

function Person(){
}

Person.prototype={
constructor:Person,
name:"Nicholas",
age:29;
job:"Software Engineer",
friends:["Shelby","Court"],
sayName:function(){
        alert(this.name);
    }
};

var person1=new Person();
var person2=new Person();

person1.friends.push("Van");

alert(person1.friends);     //"Shelby,Court,Van"
alert(person2.friends);     //"Shelby,Court,Van"
alert(person1.friends==person2.friends);    //true

原型模式优点：
可以让所有对象实例共享它所包含的属性和方法，也就是不用在构造函数中定义对象实例的信息，而是可以将这些信息直接添加到原型对象中。

原型模式缺点：
1.它省略了为构造函数传递初始化参数这一环节，结果所有实例在默认情况下都将取得相同的属性值
2.原型模式最大的问题也是其共享的本性导致的。特别是对于包含引用属性类型值的属性，问题比较突出，比如上面代码中的person1.friends==person2.friends.

四、组合使用构造函数模式和原型模式

function Person(name,age,job){
    this.name=name;
    this.age=age;
    this.job=job;
    this.friends=["Shelby","Court"];
}
Person.prototype={
    constructor:Person,
    sayName:function(){
        alert(this.name);
    }
};

var person1=new Person("Nicholas",29,"Software Engineer");
var person2=new Person("Greg",27,"Doctor");

person1.friends.push("Van");
alert(person1.friends);     //"Shelby,Count,Van"
alert(person2.friends);     //"Shelby,Count"
alert(person1.friends===person2.frineds);   //false
alert(person1.sayName===person2.sayName);   //true

组合模式优点：
1.每个实例都会有自己的一份实例属性的副本，但同时又共享着对方法的引用，最大限度地节省了内存
2.这种混成模式还支持向构造函数传递参数

这种构造函数与原型混成的模式，是目前在ECMAScript 中使用最广泛、认同度最高的一种创建自定义类型的方法。可以说，这是用来定义引用类型的一种默认模式。

五、动态原型模式

function Person(name ,age, job){
    //属性
    this.name=name;
    this.age=age;
    this.job=job;
    //方法
    if(typeof this.sayName!="function"){
        Person.prototype.sayName=function(){
            alert(this.name);
        }

    }
}
var friend=new Person("Nicholas",29,"Software Engineer");
friend.sayName();

动态原型模式优点：
它把所有信息都封装在了构造函数中，而通过在构造函数中初始化原型（仅在必要的情况下），又保持了同时使用构造函数和原型的优点。
if语句检查的可以是初始化之后应该存在的任何属性或方法——不必用一大堆if语句检查每个属性和每个方法，只要检查其中一个即可。

注意：
在使用动态原型模式时，不能使用对象字面量重写原型。如果在已经创建了实例的情况下重写原型，那么就会切断现有实例与新原型之间的联系。

六、寄生构造函数模式

function Person(name , age , job){
    var o=new Object();
    o.name=name;
    o.age=age;
    o.job=job;
    o.sayName=function(){
        alert(this.name);
    };
    return o;
}
var friends=new Person("Nicholas",29,"Software Engineer");
friends.sayName();  //"Nicholas"

除了使用new操作符并把使用的包装函数叫做构造函数之外，这个模式跟工厂模式其实是一模一样的。构造函数在不返回值的情况下，默认会返回新对象实例。而通过在构造函数的末尾添加一个return语句，可以重写调用构造函数时返回的值。

注意：
关于寄生构造函数模式，返回的对象与构造函数或者与构造函数的原型属性之间没有关系，也就是说，构造函数返回的对象与在构造函数外部创建的对象没什么不同。不能依赖instanceof操作符来确定对象类型。建议在可以使用其他模式的情况下，不要使用这种模式。

七、稳妥构造函数模式

function Person(name,age,job){
    //创建要返回的对象
    var o=new Object();

    //可以在这里定义私有变量和函数

    //添加方法
    o.sayName=function(){
        alert(name);
    };
    //返回对象
    return o;
}

var friends=Person("Nicholas",29,"Software Engineer");
friends.sayName();      //"Nicholas"

稳妥构造函数遵循与寄生构造函数类似的模式，但有两点不同：
1.实例方法不引用this
2.不使用new操作符调用构造函数

注意：
变量friends中保存的是一个稳妥对象，而除了调用sayName()方法外，没有别的方式可以访问其数据成员。
稳妥构造函数模式提供的这种安全性，使得它非常适合在某些安全执行环境——例如，ADsafe(www.adsafe.org)和Caja(http://code.google.com/p/google-caja/)提供的环境下使用。