第6章 面向对象的程序设计 6.1 javascript对象

ECMA-262 把对象定义为： “无序属性的集合， 其属性可以包含基本值、 对象或者函数。 ” 严格来讲，这就相当于说对象是一组没有特定顺序的值。对象的每个属性或方法都有一个名字，而每个名字都映射到一个值。正因为这样（以及其他将要讨论的原因） ，我们可以把 ECMAScript 的对象想象成散列表：无非就是一组名值对，其中值可以是数据或函数。

 

对象

创建自定义对象的最简单方式就是创建一个 Object 的实例，然后再为它添加属性和方法，如下所示。

var person = new Object();

person.name = "Nicholas";

person.age = 29;

person.job = "Software Engineer";

person.sayName = function(){

alert(this.name);

};

或者：

var person = {

name: "Nicholas",

age: 29,

job: "Software Engineer",

sayName: function(){

alert(this.name);

}

};

 

属性类型

ECMAScript 中有两种属性：数据属性和访问器属性。

1. 数据属性

数据属性包含一个数据值的位置。在这个位置可以读取和写入值。数据属性有 4 个描述其行为的特性。

Configurable：表示能否通过 delete 删除属性从而重新定义属性，能否修改属性的特性，或者能否把属性修改为访问器属性。

Enumerable：表示能否通过 for-in 循环返回属性。

Writable：表示能否修改属性的值。

Value：包含这个属性的数据值。读取属性值的时候，从这个位置读；写入属性值的时候，把新值保存在这个位置。这个特性的默认值为 undefined 。

对于像前面例子中那样直接在对象上定义的属性，它们的 Configurable 、 Enumerable和 Writable特性都被设置为 true ，而 Value特性被设置为指定的值。

要修改属性默认的特性，必须使用 ECMAScript 5 的 Object.defineProperty() 方法(ie8以上支持)。这个方法接收三个参数：属性所在的对象、属性的名字和一个描述符对象。

示例如下：

var person = {};

Object.defineProperty(person, "name", {

writable: false,

value: "Nicholas"

});

alert(person.name); //"Nicholas"

person.name = "Greg";

alert(person.name); //"Nicholas"

例子中创建了一个名为 name 的属性，它的值 "Nicholas" 是只读的。这个属性的值是不可修改的，如果尝试为它指定新值，则在非严格模式下，赋值操作将被忽略；在严格模式下，赋值操作将会导致抛出错误。

2.访问器属性

访问器属性不包含数据值；它们包含一对儿 getter 和 setter 函数（不过，这两个函数都不是必需的） 。

在读取访问器属性时，会调用 getter 函数，这个函数负责返回有效的值；在写入访问器属性时，会调用

setter 函数并传入新值，这个函数负责决定如何处理数据。访问器属性有如下 4 个特性：

Configurable：表示能否通过 delete 删除属性从而重新定义属性，能否修改属性的特性，或者能否把属性修改为数据属性。对于直接在对象上定义的属性，这个特性的默认值为true 。

Enumerable：表示能否通过 for-in 循环返回属性。对于直接在对象上定义的属性，这个特性的默认值为 true 。

Get：在读取属性时调用的函数。默认值为 undefined 。

Set：在写入属性时调用的函数。默认值为 undefined 。

同样，访问器属性不能直接定义，必须使用 Object.defineProperty() 来定义。

示例如下：

var book = {

_year: 2004,

edition: 1

};

Object.defineProperty(book, "year", {

get: function(){

return this._year;

},

set: function(newValue){

if (newValue > 2004) {

this._year = newValue;

this.edition += newValue - 2004;

}

}

});

book.year = 2005;

alert(book.edition); //2

以上代码创建了一个 book 对象，并给它定义两个默认的属性： _year 和 edition 。 _year 前面的下划线是一种常用的记号，用于表示只能通过对象方法访问的属性。而访问器属性 year 则包含一个getter 函数和一个 setter 函数。 getter 函数返回 _year 的值， setter 函数通过计算来确定正确的版本。 因此，把 year 属性修改为 2005 会导致 _year 变成 2005，而 edition 变为 2。这是使用访问器属性的常见方式，即设置一个属性的值会导致其他属性发生变化。

不一定非要同时指定 getter 和 setter。只指定 getter 意味着属性是不能写，尝试写入属性会被忽略。在严格模式下，尝试写入只指定了 getter 函数的属性会抛出错误。类似地，只指定 setter 函数的属性也不能读，否则在非严格模式下会返回 undefined ，而在严格模式下会抛出错误。

 

定义多个属性

由于为对象定义多个属性的可能性很大，ECMAScript 5 又定义了一个 Object.defineProperties() 方法。利用这个方法可以通过描述符一次定义多个属性。这个方法接收两个对象参数：第一个对象是要添加和修改其属性的对象，第二个对象的属性与第一个对象中要添加或修改的属性一一对应。

例如：

var book = {};

Object.defineProperties(book, {

_year: {

value: 2004

},

edition: {

value: 1

},

year: {

get: function(){

return this._year;

},

set: function(newValue){

if (newValue > 2004) {

this._year = newValue;

this.edition += newValue - 2004;

}

}

}

});

以上代码在 book 对象上定义了两个数据属性（ _year 和 edition ）和一个访问器属性（ year ） 。最终的对象与上一节中定义的对象相同。唯一的区别是这里的属性都是在同一时间创建的。支持 Object.defineProperties() 方法的浏览器有 IE9+、Firefox 4+、Safari 5+、Op

读取属性的特性

使用 ECMAScript 5 的 Object.getOwnPropertyDescriptor() 方法，可以取得给定属性的描述符。这个方法接收两个参数：属性所在的对象和要读取其描述符的属性名称。

返回值是一个对象，如果是访问器属性，这个对象的属性有 configurable 、 enumerable 、 get 和 set ；如果是数据属性，这个对象的属性有 configurable 、 enumerable 、 writable 和 value 。

例如：

var book = {};

Object.defineProperties(book, {

_year: {

value: 2004

},

edition: {

value: 1

},

year: {

get: function(){

return this._year;

},

set: function(newValue){

if (newValue > 2004) {

this._year = newValue;

this.edition += newValue - 2004;

}

}

}

});

 

在 JavaScript 中， 可以针对任何对象——包括 DOM 和 BOM 对象， 使用 Object.getOwnProperty-Descriptor() 方法。支持这个方法的浏览器有 IE9+、Firefox 4+、Safari 5+Opera 12+和 Chrome。

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

工厂模式创建对象

考虑到在 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("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");

例子中， Person() 函数取代了 createPerson() 函数，但是两个函数存在不同之处：

1.没有显式地创建对象；

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

3.没有 return 语句。

此外，还应该注意到函数名 Person 使用的是大写字母 P。按照惯例，构造函数始终都应该以一个

大写字母开头，而非构造函数则应该以一个小写字母开头。这个做法借鉴自其他 OO 语言。

要创建 Person 的新实例，必须使用 new 操作符。

以这种方式调用构造函数实际上会经历以下 4个步骤：

1. 创建一个新对象；

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

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

4. 返回新对象。

例子中person1 和 person2 分别保存着 Person 的一个不同的实例。这两个对象都

有一个 constructor （构造函数）属性，该属性指向 Person ，如下所示：

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

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

对象的 constructor 属性最初是用来标识对象类型的。不过 instanceof 操作符要更可靠一些。

alert(person1 instanceof Person); //true

alert(person2 instanceof Person); //true

构造函数与普通函数

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

// 当作构造函数使用

var person = new Person("Nicholas", 29, "Software Engineer");

person.sayName(); //"Nicholas"

// 作为普通函数调用

Person("Greg", 27, "Doctor"); // 添加到 window

window.sayName(); //"Greg"

// 在另一个对象的作用域中调用

var o = new Object();

Person.call(o, "Kristen", 25, "Nurse");

o.sayName(); //"Kristen"

不使用 new 操作符调用 Person()，相当于属性和方法都被添加给 window对象了，因为当在全局作用域中调用一个函数时， this 对象总是指向 Global 对象（在浏览器中就是 window 对象） 。同样也可以使用 call() （或者 apply() ）在某个特殊对象的作用域中调用 Person() 函数。 这里是在对象 o 的作用域中调用的， 因此调用后 o 就拥有了所有属性和 sayName()方法。

构造函数问题

构造函数模式虽然好用，但也并非没有缺点。使用构造函数的主要问题，就是每个方法都要在每个实例上重新创建一遍。例子中， 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)"); //  与声明函数在逻辑上是等价的

}

从这个角度上来看构造函数，更容易明白每个 Person 实例都包含一个不同的 Function 实例。以这种方式创建函数，会导致不同的作用域链和标识符解析，但创建 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() 函数。这样做确实解决了两个函数做同一件事的问题，可是新问题又来了：在全局作用域中定义的函数实际上只能被某个对象调用，这让全局作用域有点名不副实。而更让人无法接受的是：如果对象需要定义很多方法，那么就要定义很多个全局函数，于是我们这个自定义的引用类型就丝毫没有封装性可言了。

针对这个问题可以通过使用后续原型模式来解决。