JavaScript之创建对象

虽然Object构造函数或对象字面量都可以用来创建单个对象，但这些方式有个明显的缺点：使用同一个接口创建很多对象，会产生大量的重复代码。

一、工厂模式

用函数来封装以特定接口创建对象的细节，如下：

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("Nicholas",29,"Software Engineer");var person2 = createPerson("Greg",27,"Doctor");

函数createPerson() 能够根据接受的参数来构建一个包含所有必要信息的Person 对象。可以无数次地调用这个函数，而每次它都会返回一个包含三个属性一个方法的对象。工厂模式虽然解决了创建多个相似对象的问题，但却没有解决对象识别的问题（即怎样知道一个对象的类型）。

alert(person1 instanceof createPerson);//false

二、构造函数模式

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("Nicholas",29,"Software Engineer");var person2 = new Person("Greg",27,"Doctor");

在这个例子中，Person() 函数取代了 createPerson() 函数。他们之间的不同之处如下：

               *没有显式地创建对象；

               *直接将属性和方法赋给了 this 对象；

               *没有return 语句。

此外，还应该注意到函数名Person 使用的是大写字母P。按照惯例，构造函数始终都应该以一个大写字母开头，而非构造函数则应该以一个小写字母开头。主要是为了区别于ECMAScript 中的其他函数；因为构造函数本身也是函数，只不过可以用来创建对象而已。

要创建 Person 的新实例，必须使用 new 操作符。以这种方式调用构造函数实际上会经历以下4个步骤：

            （1）创建一个新对象；

            （2）将构造函数的作用域赋给新对象（因此this就指向了这个新对象）；

            （3）执行构造函数中的代码（为这个新对象添加属性）；

            （4）返回新对象。

前面两个对象都有一个constructor （构造函数）属性，该属性指向 Person：

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

对象的constructor 属性最初是用来标识对象类型的。但是，提到检测对象类型，还是 instanceof 操作符要更可靠一些。我们在这个例子中创建的所有对象既是Object的实例，同时也是Person 的实例，这一点通过instanceof 操作符可以得到验证。

alert(person1 instanceof Object);//truealert(person1 instanceof Person);//true

创建自定义的构造函数意味着将来可以将它的实例标识为一种特定的类型；而这正是构造函数模式胜过工程模式的地方。

1、将构造函数当作函数

构造函数与其它函数的唯一区别，就在于调用他们的方式不同。不过，构造函数毕竟也是函数，不存在定义构造函数的特殊语法。任何函数，只要通过 new 操作符来调用，那它就可以作为构造函数；而任何函数，如果不通过 new 操作符来调用，那它就跟普通函数也不会有什么两样。

例如，前面例子中定义的 Person() 函数可以通过下列任何一种方式来调用。

//当作构造函数使用var person = new Person("Nicholas",29,"Software Engineer");person.sayName();//Nicholas//作为普通函数调用Person("Greg",27,"Doctor");//添加到windowwindow.sayName();//Greg//在另一个对象的作用域中调用var o = new Object();Person.call(o,"Kristen",25,"Nurse");o.sayName();//Kristen

2、构造函数的问题

使用构造函数的主要问题，就是每个方法都要在每个实例上重新创建一遍。在前面的例子中，person1 和 person2 都有一个名为sayName() 的方法，但那两个方法不是同一个Function 的实例。因为，ECMAScript中的函数是对象，每定义一个函数，也就是实例化了一个对象。从逻辑角度讲，此时的构造函数也可以这样定义：

function Person(name, age, job){this.name = name;this.age = age;this.job = job;this.sayName = new Function("alert(this.name)");//与声明函数在逻辑上是等价的}

说明白些，以这种方式创建函数，会导致不同的作用域链和标识符解析，但创建Function 新实例的机制仍然是相同的。因此，不同实例上的同名函数是不相等的，以下代码可以证明：

alert(person1.sayName == person2.sayName);//false

然而，创建两个完成同样任务的Function 实例的确没有必要；况且有this 对象在，根本不用在执行代码前就把函数绑定到特定对象上面。因此，大可像下面这样，通过把函数定义转移到构造函数外部来解决这个问题。

function Person(name, age, job){this.name = name;this.age = age;this.job = job;this.sayName = sayName;}function sayName(){alert(this.name);}var person1 = new Person("Nicholas",29,"Software Engineer");var person2 = new Person("Greg",27,"Doctor");

在这个例子中，我们把sayName() 函数的定义转移到了构造函数外部。而在构造函数内部，我们将sayName 属性设置成等于全局的 sayName 函数。这样一来，由于sayName 包含的是一个指向函数的指针，因此person1 和person2 对象就共享了在全局作用域中定义的同一个sayName() 函数。

这样做确实解决了两个函数做同一件事的问题，可是新问题又来了：在全局作用域中定义的函数实际上只能被某个对象调用，这让全局作用域有点名不副实。而更让人无法接受的是：如果对象需要定义很多方法，那么就要定义很多个全局函数，于是我们这个自定义的引用类型就丝毫没有封装性可言了。原型模式可以解决这些问题：

三、原型模式

我们创建的每个函数都有一个prototype（原型）属性，这个属性是一个指针，指向一个对象，而这个对象的用途是包含可以由特定类型的所有实例共享的属性和方法。如果按照字面意思来理解，那么prototype就是通过调用构造函数而创建的那个对象实例的原型对象。使用原型对象的好处是可以让所有对象实例共享它所包含的属性和方法。换句话说，不必在构造函数中定义对象实例的信息，而是可以将这些信息直接添加到原型对象中，如下所示：

function Person(){}Person.prototype.name = "Nicholas";Person.prototype.age = 29;Person.prototype.job = "Software Engineer";Person.prototype.sayName = function(){alert(this.name);};var person1 = new Person();person1.sayName();//Nicholasvar person2 = new Person();person2.sayName();//Nicholasalert(person1.sayName == person2.sayName);//true

1、理解原型对象

JavaScript高级程序设计（第3版）P148

虽然可以通过对象实例访问保存在原型中的值，但却不能通过对象实例重写原型中的值。如果我们在实例中添加了一个属性，而该属性与实例原型中的一个属性同名，那我们就在实例中创建该属性，该属性就会屏蔽原型中的那个属性：

function Person(){}Person.prototype.name = "Nicholas";Person.prototype.age = 29;Person.prototype.job = "Software Engineer";Person.prototype.sayName = function(){alert(this.name);};var person1 = new Person();var person2 = new Person();person1.name = "Greg";alert(person1.name);//Greg——来自实例alert(person2.name);//Nicholas——来自原型

当为对象实例添加一个属性时，这个属性就会屏蔽原型对象中保存的同名属性；换句话说，添加这个属性只会阻止我们访问原型中的那个属性，但不会修改那个属性。即使将这个属性设置为null ，也只会在实例中设置这个属性，而不会恢复其指向原型的连接。不过，使用delete操作符则可以完全删除实例属性，从而让我们能够重新访问原型中的属性，如下所示：

function Person(){}Person.prototype.name = "Nicholas";Person.prototype.age = 29;Person.prototype.job = "Software Engineer";Person.prototype.sayName = function(){alert(this.name);};var person1 = new Person();var person2 = new Person();person1.name = "Greg";alert(person1.name);//Greg——来自实例alert(person2.name);//Nicholas——来自原型delete person1.name;alert(person1.name);//Nicholas——来自原型

使用hasOwnProperty() 方法可以检测一个属性是存在于实例中，还是存在于原型中。这个方法只在给定属性存在于对象实例中时，才会返回true。上面例子：

function Person(){}Person.prototype.name = "Nicholas";Person.prototype.age = 29;Person.prototype.job = "Software Engineer";Person.prototype.sayName = function(){alert(this.name);};var person1 = new Person();var person2 = new Person();alert(person1.hasOwnProperty("name"));//falseperson1.name = "Greg";alert(person1.name);//Greg——来自实例alert(person1.hasOwnProperty("name"));//truealert(person2.name);//Nicholas——来自原型alert(person2.hasOwnProperty("name"));//falsedelete person1.name;alert(person1.name);//Nicholas——来自原型alert(person1.hasOwnProperty("name"));//false

通过使用 hasOwnProperty() 方法，什么时候访问的是实例属性，什么时候访问的是原型属性就一清二楚了。

2、原型对象的问题

首先，他忽略了为构造函数传递初始化参数这一环节，结果所有实例在默认情况下都将取得相同的属性值。虽然这会在某种程度上带来一些不方便，但还不是原型的最大问题。原型模式的最大问题是由其共享的本性所导致的。

原型中所有属性是被很多实例共享的，这种共享对于函数非常合适。对于那些包含基本值的属性倒也说得过去，毕竟，通过在实例上添加一个同名属性，可以隐藏原型中的对应属性。然而，对于包含引用类型值的属性来说，问题就比较突出了。如下：

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

此时，Person.prototype 对象有一个名为friends 的属性，该属性包含一个字符串数组。然后，然后创建了Person 的两个实例。接着，修改了person1.friends 引用的数组，向数组中添加了一个字符串。由于friends 数组存在于Person.prototype 而非person1 中，所以刚刚的修改也会通过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,Court,Van"alert(person2.friends);//"Shelby,Court"alert(person1.friends === person2.friends);//falsealert(person1.sayName === person2.sayName);//true

五、动态原型模式

动态原型模式把所有信息都封装在了构造函数中，而通过在构造函数中初始化原型（仅在必要的情况下），又保持了同时使用构造函数和原型的优点。换句话说，可以通过检查某个应该存在的方法是否有效，来决定是否需要初始化原型。如下：

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();

这里只在sayName() 方法不存在的情况下，才会将它添加到原型中。这段代码只会在初次调用构造函数时才会执行。此后，原型已经完成初始化，不需要再做什么修改了。其中，if 语句检查的可以是初始化之后应该存在的任何属性和方法——不必用一大堆if 语句检查每个属性和每个方法；只要检查其中一个即可。对于采用这种模式创建的对象，还可以使用instanceof 操作符确定他的类型。