面向对象的程序设计

面向对象的语言有一个标志,那就是它们都有类的概念,而通过类可以创建任意多个具有相同属性和方法的对象。ECMAScript 没有类的概念,因此它的对象也与基于类的语言中的对象有有所不同。

理解对象

属性类型

数据属性

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

  • [[Configurable]] : 表示能否通过 delete 删除属性从而重新定义属性,能否修改属性的特性,或者能否把属性修改为访问器属性。默认为 true。
  • [[Enumerable]] : 表示能否通过 for-in 循环返回属性。默认 true。
  • [[Writable]] : 表示能否修改属性的值。默认 true。
  • [[Value]] : 包含这个属性的数据值。
1
2
3
4
5
6
7
8
9
10
11
12
//像下面这样直接在对象上定义的属性,它的 [[Configurable]]、[[Enumerable]]、[[Writable]] 特性都被设置为 true。
var person = {
name: 'max'
}
//要修改属性默认的特性,必须使用ECMAScript5的 Object.defineProperty() 方法。这个方法接受三个参数:属性所在的对象、属性的名字和一个描述符对象。其中描述符对象的属性必须是:configurable、enumerable、writable 和 valuie。
var person = {};
Object.defineProperty(person, 'name', {
writable: false,//不可修改
value: 'max'
});
//在调用 Object.defineProperty() 方法时,如果不指定,configurable、enumerable 和 writable 特性的默认值都为 false。

访问器属性

访问器属性不包含数据值;它们包含一对儿 getter 和 setter 函数(不是必须)。在读取访问器属性时,会调用 getter 函数,这个函数复制返回有效的值;在写入访问器属性时,会调用 setter 函数并传入新值,这个函数负责决定如何处理数据。访问器属性有如下4个属性:

  • [[Configurable]] : 表示能否通过 delete 删除属性从而重新定义属性,能否修改属性的特性,或者能否把属性修改为访问器属性。默认 true。
  • [[Enumerable]] : 表示能否通过 for-in 循环返回属性。默认 true。
  • [[Get]] : 在读取属性时调用的函数。默认undefined
  • [[Set]] : 在写入属性时调用的函数。默认undefined
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
//访问器属性不能直接定义,必须使用 Object.defineProperty() 来定义。
//不一定非要同时指定 getter 和 setter。只指定 getter 意味着属性不能写;反之意味着不能读取。
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;
}
}
});

定义多个属性

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
//利用 Object.defineProperties() 可以通过描述符一次定义多个属性。这个方法接受两个对象参数:第一个对象时要添加和修改器属性的对象,第二个对象的属性于第一个对象种要添加或修改的属性一一对应。
var book = {};
Object.defineProperties(book, {
_year: {
writable: true,
value: 2004
},
edition: {
writable: true,
value: 1
},
year: {
get: function(){
return this._year;
},
set: function(){
if(newValue > 2004){
this._year = newValue;
this.edition += newValue - 2004;
}
}
}
});

读取属性的特性

使用 Object.getOwnPropertyDescriptor() 方法,可以取得给定属性的描述符。这个方法接收两个参数:属性所在的对象和要读取其描述符的属性名称。返回值是一个对象,如果是访问器属性,这个对象的属性有 configurable、enumerable、get 和 set;如果是数据属性,这个对象的属性有 configurable、enumerable 和 writable 和 value。

创建对象

工厂模式

1
2
3
4
5
6
7
8
9
10
11
12
13
function createPerson(name, age, job){
var o = {
name: name,
age: age,
job: job,
sayName: function(){
alert(this.name);
}
}
return o;
}
var person1 = createPerson('Nicholas', 29, 'Software Engineer');
var person2 = createPerson('Greg', 27, 'Doctor');

构造函数模式

1
2
3
4
5
6
7
8
9
10
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 操作符来调用,那它就可以作为构造函数。
使用构造函数模式也有一些问题,就是每个方法都要在每个实例上重新创建一遍。在前面的例子中,person1 和 person2 都有个 sayName() 方法,但那两个方法不是同个 Function 的实例。

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

原型模式

理解原型对象

我们创建的每个函数都有一个 prototype (原型)属性,这个属性是一个指针,指向一个对象,而这个对象的用途就是包含可以由特定类型的所有实例共享的属性和方法。换句话说,不必在构造函数中定义对象实例的信息,而是可以将这些信息直接添加到原型对象中。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
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();// 'Nicholas'
var person1 = new Person();
person1.sayName();// 'Nicholas'
alert(person1.sayName == person2.sayName);//true
alert(Person.prototype.isPrototypeOf(person1));//true
alert(Person.prototype.isPrototypeOf(person2));//true
alert(Object.getPrototypeOf(person1) == Person.prototype);//true
alert(Object.getPrototypeOf(person1).name);//'Nicholas'

无论什么时候,只要创建了一个新函数,就会根据一组特定的规则为该函数创建一个 prototype 属性,这个属性指向函数的原型对象。在默认情况下,所有原型对象都会自动获得一个 constructor(构造函数)属性,这个属性包含一个指向 prototype 属性所在函数的指针。前面例子中 Person.prototype.constructor 指向 Person。

当调用构造函数创建一个新实例后,该实例的内部将包含一个指针(内部属性),指向构造函数的原型。ECMA-262管这个指针叫[[Prototype]]。虽然没有标准方式访问[[Prototype]],但在现代浏览器中,每个对象上都支持一个属性 __proto__

[[Prototype]]

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
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 = 'max';
alert(person1.sayName);//'max' -- 来自实例
alert(person2.sayName);//'Nicholas' -- 来自原型
alert(person1.hasOwnProperty('name'));//true
delete person1.name;
alert(person1.sayName);//'Nicholas' -- 来自原型
alert(person1.hasOwnProperty('name'));//false

原型与 in 操作符

有两种方法使用 in 操作符:单独使用和在 for-in 循环种使用。单独使用时,in 操作符会在同个对象能够访问给定属性时返回 true,无论属性存在于实例种还是原型中。

1
2
3
4
5
6
7
8
function Person(){}
Person.prototype.name = 'Nicholas';
var person1 = new Person();
alert('name' in person1);//true
person1.name = 'max';
alert('name' in person1);//true

因此,同时使用 hasOwnProperty() 方法和 in 操作符,就可以确定该属性到底是存在于对象中,还是存在于原型中。
由于 in 操作符只要通过对象能够访问到属性就会返回 true,hasOwnProperty() 只在属性存在与实例中时才返回 true,所以只要 in 操作符返回 true 而 hasOwnProperty() 返回 false,就可以确定属性是原型中的属性。

1
2
3
function hasPrototypeProperty(object, name){
return !object.hasOwnProperty(name) && (name in object);
}

要取得对象上所有可枚举的实例属性,可以使用ECMAScript5的 Object.keys() 方法。这个方法接收一个对象作为参考,返回一个所有可枚举属性的字符串数组。
如果像得到所有实例属性,无论是否可枚举,都可以使用 Object.getOwnPropertyNames() 方法。

更简单的原型语法

1
2
3
4
5
6
7
8
9
10
11
functio Person(){}
Person.prototype = {
constructor: Person,//必须指向构造函数
name: 'Nicholas',
age: 29,
job: 'Software Engineer',
sayName: function(){
alert(this.name);
}
}

原型的动态性

可以随时为原型添加属性和方法,并且修改能够立即在所有对象实例中反应出来,但如果是重写整个原型对象,就等于切断了构造函数与最初原型之间的联系。实例中的指针仅指向原型,而不指向构造函数。

原型对象的问题

原型中所有属性是被很多实例共享的,如果原型属性中含有引用类型的值,那么实例1修改此属性后,实例2的此属性也会发生变化。因此,原型模式很少单独使用。

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

创建自定义类型的最常见方式,就是组合使用构造函数模式与原型模式。构造函数模式用于定义实例属性,而原型模式用于定义方法和共享的属性。结果,每个实例都会有子集的一份实例属性的副本,但同时又共享着对方法的引用。这种模式是目前使用最广泛、认同度最高的一种常见自定义类型的方法。可以说是定义引用类型的默认模式

1
2
3
4
5
6
7
8
9
10
11
12
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);
}
}

继承

原型链

原型链的基本思路是利用原型让一个引用类型继承另一个引用类型的属性和方法。

默认的原型

所有引用类型默认都继承了 Object,而这个继承也是通过原型链实现的。所有函数的默认原型都是 Object 的实例,因此默认原型都会包含一个内部指针,指向 Object.prototype。

确定原型和实例的关系

1
2
3
4
5
6
7
//使用 instanceof 操作符,只要用这个操作符来测试实例与原型链中出现过的构造函数,结果就返回 true。
alert(person1 instanceof Person);//true
alert(person1 instanceof Object);//true
//使用 isPrototypeOf() 方法,只要是原型链中出现过的原型,都可以说是该原型链所派生的实例的原型,因此也会返回 true。
alert(Object.prototype.isPrototypeOf(person1));//true
alert(Person.prototype.isPrototypeOf(person1));//true

谨慎定义方法

子类型又时候需要覆盖超类型中的某个方法,或者需要添加超类型中不存在的方法。但不管怎么样,给原型添加方法的代码一定要放在替换原型的语句之后。

借用构造函数

这种技术的基本思想相当简单,即在子类型构造函数的内部调用超类型构造函数。因此通过使用 apply() 和 call() 方法也可以在新创建的对象上执行构造函数。

1
2
3
4
5
6
7
8
function SuperType(){
this.colors = ['red', 'blue', 'green'];
}
function SubType(){
//继承了 SuperType
SuperType.call(this);
}

组合继承

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
function SuperType(name){
this.name = name;
this.colors = ['red', 'blue', 'green'];
}
SuperType.prototype.sayName = function(){
alert(this.name);
};
function SubType(name, age){
SuperType.call(this, name);
this.age = age;
}
SubType.prototype = new SuperType();
SubType.prototype.constructor = SubType;
SubType.prototype.sayAge = function(){
alert(this.age);
}

寄生组合式继承

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
function inheritPrototype(subType, superType){
var prototype = Object(superType.prototype); //创建对象
prototype.constructor = subType; //增强对象
subType.prototype = prototype; //指定对象
}
function SuperType(name){
this.name = name;
this.colors = ['red', 'blue', 'green'];
}
SuperType.prototype.sayName = function(){
alert(this.name);
}
function SubType(name, age){
SuperType.call(this, name);
this.age = age;
}
inheritPrototype(SubType, SuperType);
SubType.prototype.sayAge = function(){
alert(this.age);
}