标签（空格分隔）： js
1. 工厂模式
考虑到在ECMAScript中无法创建类，开发人员就发明了一种函数，用函数来封装以特定接口创建对象的细节，如下面的例子所示：
实现起来是在一个函数内创建好对象，然后把对象返回.
function createPerson(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 person1 = createPerson("lvyweb",18,"front-end Engineer");
var person2 = createPerson("lvy",18,"student");
// console.log(person1);
// console.log(person2);
函数createPerson()能够根据接受的参数来构建一个包含所有必要信息的person对象。可以无数次的调用这个函数，而每次它都会返回一个包含三个属性一个方法的对象。工厂模式虽然解决了创建多个相似对象的问题，但却没有解决对象识别的问题（即怎样知道一个对象的类型）。随着JavaScript的发展，又一个新模式出现了。
2. 构造函数模式
ECMAScript中的构造函数可以用来创建特定类型的对象。像Object和Array这样的原生构造函数，在运行时会自动出现在执行环境中。此外，也可以创建自定义的构造函数，从而定义自定义对象类型的属性和方法。例如，可以使用构造函数模式将前面的例子重写如下：
function Person(name, age, job) {
this.name = name;
this.age = age;
this.job = job;
this.sayName = function () {
alert(this.name);
}
}
var person1 = new Person("lvyweb", 18, "front-end Engineer");
var person2 = new Person("lvy", 18, "student");
console.log(person1.name);
//这个例子中创建的所有对象既是object的实例，同时也是Person的示例
console.log(person2 instanceof Object);//true
console.log(person2 instanceof Person);//true
与工厂模式相比，构造函数的不同之处：
- 没有显式的创建对象
- 直接将属性和方法赋值给了this
- 没有return语句
- 要创建新实例，必须要使用new操作符（否则属性和方法将会被添加到window对象）
- 构造函数的函数名以大写字母开头，而非构造函数以一个小写字母开头
- 可以使用instanceof操作符检测对象类型
构造函数的问题:
构造函数内部的方法会被重复创建，不同实例内的同名函数是不相等的。可通过将方法移到构造函数外部解决这一问题，但面临新问题：封装性不好。
alert(person1.sayName == person2.sayName); //false
function Person(name, age, job) {
this.name = name;
this.age = age;
this.job = job;
this.sayName = sayName;
}
function sayName() {
alert(this.name);
}
这些问题可通过原型模式解决。
3. 原型模式
我们创建的每个函数都有一个prototype（原型）属性，这个属性是一个指针，指向一个对象，而这个对象的用途是包含可以由特定的所有实例共享的属性和方法（prototype就是通过调用构造函数而创建的那个对象实例的原型对象）。使用原型对象的好处是可以让所有对象实例共享它所包含的属性和方法。换句话说，不必在构造函数中定义对象实例的信息，而是可以将这些信息直接添加到原型对象中，如下面例子所示：
function Person(){}
Person.prototype.name ="lvyweb";
Person.prototype.age = 18;
Person.prototype.job = "front-end Engineer";
Person.prototype.sayName = function(){
alert(this.name);
}
var person1 = new Person();
console.log(person1.name);
person1.sayName() //lvyweb
var person2 = new Person();
console.log(person2.name);
person2.sayName() //lvyweb
console.log(person1.name == person2.name);//true
更常见的做法是用一个包含所有属性和方法的对象字面量来重写整个原型对象，并重设constructor属性。
function Person(){
}
Person.prototype ={
name: "lvyweb",
age: 18,
job: "front-end Engineer",
sayName :function(){
alert(this.name);
}
}
原型对象的问题：
- 它省略了为构造函数传递初始化参数这一环节，结果所有实例在默认情况下都将取得相同的属性值。虽然这会在一定程度带来一定的不便，但不是原型的最大问题，最大的问题是由其共享的本性所决定的。
- 原型中的所有属性是被很多实例共享的，这种共享对于函数非常合适。对于包含基本值的属性可以通过在实例上添加一个同名属性，隐藏原型中的对应属性。然而，对于包含引用数据类型的值来说，问题比较突出。来看下面例子：
function Person(){
}
Person.prototype = {
constructor: Person,
name: "lvyweb",
age: 18,
job: "front-end Engineer",
friends: ["Shelby","Court"],
sayName: function(){
alert(this.name);
}
}
var person1 = new Person();
var person2 = new Person();
person1.friends.push("Van");
console.log(person1.friends);//["Shelby", "Court", "Van"]
console.log(person2.friends);//["Shelby", "Court", "Van"]
console.log(person1.friends == person2.friends);//true
在此，Person,prototype对象有一个名为friends的属性，该属性包含以恶搞字符串数组。然后。创建了Person的两个实例。接着修改了person1.friends引用的数组，向数组中添加了一个字符串。由于friends数组存在于Person.prototype而非person1中，所以刚刚提到的修改也会通过person2.friends（与person1.friends指向同一个数组）反映出来。假如我们的初衷就是像这样在所有实例中共享一个数组，那么对这个结果无话可说。可是，实例一般都是要有自己的全部属性的。而这个问题正是我们很少看到有人单独使用原型模式的原因所在。
4. 组合使用构造函数模式和原型模式
创建自定义类型的最常见方式，就是组合使用构造函数模式和原型模式。构造函数模式用于定义实例属性，而原型模式用于定义方法和共享属性，结果，每个实例都会有自己的一份实例属性的副本，但同时又共享着对方的引用，最大限度的节省了内存。另外，这中混成模式还支持向构造函数传递参数；可谓是集两种模式之长，下面的代码重写了前面的例子。
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("lvyweb",18,"front-end Engineer");
var person2 = new Person("lvy",16,"Engineer");
person1.friends.push("Van");
console.log(person1.friends);//["Shelby", "Court", "Van"]
console.log(person2.friends);//["Shelby", "Court"]
console.log(person1.friends == person2.friends);//false
console.log(person1.sayName == person2.sayName);//true
在这个例子中，实例属性都是在构造函数中定义的，而由所有实例共享的属性constructor和方法sayName()则是在原型中定义的。而修改了person1.friends（向其中添加一个新字符串），并不会影响到person2.friends，因为它们分别引用了不同的数组。
这种构造函数与原型混成的模式，是目前在ECMAScript中使用最广泛，认同度最高的一种创建自定义类型的方法。可以说，这是用来定义引用类型的一种默认模式。
5. 动态原型模式
当我们看到独立的构造函数和原型时，很可能会感到困惑。动态创建原型模式正是致力于解决这个问题一个方案，它把所有信息都封装在了构造函数中，而通过在构造函数中初始化原型（仅在必要的情况下），又保持了同时使用构造函数和原型的优点。换句话说，可以通过检车某个应该存在的方法是否有效，来决定是否需要初始化原型，来看一个例子：
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 friends = new Person("lvyweb",18,"front-end Engineer");
friends.sayName();
这里只有sayName（）不存在的情况下，才会将它添加到原型中。这段代码只会在初次调用构造函数时才执行。这里对原型所做的修改，能够立刻在所有实例中得到反映。
6. 寄生构造函数模式
通常，在前述的几种模式都不适用的情况下，可以使用寄生构造函数模式。这种模式的基本思想是构建一个函数，该函数的作用仅仅是封装创建对象的代码，然后再返回新创建的对象；但从表面上看，这个函数又很像典型的构造函数。下面是一个例子。
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 friend = new Person("lvyweb",18,"front-end Engineer");
friend.sayName(); //lvyweb
构造函数在不返回值的情况下，默认会返回新对象实例。而通过在构造函数的末尾添加一个return语句，可以重写调用构造函数时返回的值。
这个模式可以在特殊的情况下用来为对象创建构造函数。假设我们想创建一个具有额外方法的特殊数组。由于不能直接修改Array构造函数，因此可以使用这个模式。
function SpecialArray(){
//创建数组
var values = new Array();
//添加值
values.push.apply(values,arguments);
//添加方法
values.toLocaleString = function(){
return this.join("|");
}
//返回数组
return values;
}
var colors = new SpecialArray("skyblue","pink","yellowgreen");
console.log(colors.toLocaleString());//skyblue|pink|yellowgreen
寄生构造函数的问题：
返回的对象与构造函数或者构造函数的原型属性之间没有关系，也就是说，构造函数返回的对象与在构造函数外部创建的对象没有什么不同。为此，不能依赖instanceof操作符来确定对象类型。由于存在上述问题，能使用其他模式的情况下，不要使用这种模式。
7. 稳妥构造函数模式
稳妥对象最适合在一些安全的环境中（这些环境中会禁止使用this和new），或者在防止数据被其他应用程序（如Mashup程序）改动时使用。稳妥构造函数遵循与寄生构造函数类似的模式，但有两点不同：一是新创建对象的实例方法不引用this，二是不使用new操作符调用构造函数。按照稳妥构造函数的要求，可以将前面的Person构造函数重写如下：
function Person(name,age,job){
//创建要返回的对象
var o = new Object();
//可以在这里定义私有变量和函数
//添加方法
o.sayName = function(){
alert(name);
}
//返回对象
return o;
}
注意，在以这种模式创建的对象中，除了使用sayName（）方法之外，没有其他办法访问name的值。可以像下面使用稳妥的Person构造函数。
var friend = Person("lvyweb",18,"front-end Engineer");
friend.sayName();//lvyweb
这样，变量friend中保存的值是一个稳妥对象，而除了调用sayName（）方法外，没有别的方式可以访问其数据成员。即使有其他代码会给这个对象添加方法或数据成员，但也不可能有别的办法访问传入到构造函数中的原始数据。稳妥构造函数模式提供的这种安全性，使得它非常适合在某些安全执行环境————例如，ADsafe（www.adsafe.org）和Caja（http://code.google.com/p/google-caja/）提供的环境下使用。
------------------此文章摘自Professional JavaScript for Web Developers 3rd Edition
