JavaScript之原型与原型链

JavaScript之原型与原型链

在基于类的语言中,对象是类的实例,并且类可以从另一个类继承,如Java;JavaScript则是一门基于原型的语言,以原型链实现继承,其对象可以直接继承自另一对象,此篇详细阐述JavaScript之原型与原型链。

原型

Javascript中创建的每个函数都有一个prototype属性,这个属性是一个指针,指向一个对象,这个对象的作用即是包含可以由特定类型实例共享的属性和方法,这个对象就是函数的原型对象。

默认情况,所有的原型对象都会有一个constructor属性,这个属性包含一个指向prototype属性所在函数的指针。

调用构造函数创建一个新实例后,实例的内部将包含一个指向构造函数原型对象的指针,在ECMA-262中定义此指针为[[Prototype]],并不能被显式的访问到,而在Firefox,Safari和Chrome中每个对象上有一个__proto__属性。

__proto__显示的是实例与构造函数原型对象间的关系,而非实例与构造函数间的关系。

1
2
3
4
5
6
7
8
9
10

function Animal(name) {
this.name = name;
}
Animal.prototype.age = 3;
Animal.prototype.getName = function() {
return this.name;
};
var animal = new Animal('Dog');
console.log(animal.getName()); //输出Dog

以上代码中,Animal为构造函数,Animal.prototype指向构造函数原型对象;原型对象中constructor属性指向构造函数,即Animal.prototype.constructor指向Animal;在构造函数实例中,其__proto__属性指向构造函数原型对象。

原型与实例属性访问

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

function Animal(name) {
this.name = name;
}
Animal.prototype.age = 3;
Animal.prototype.getName = function() {
return this.name;
};
var animal1 = new Animal('Dog');
var animal2 = new Animal('Cat');
console.log(animal1.age); //输出3--原型属性
console.log(animal2.age); //输出3--原型属性
animal2.age = 4;
console.log(animal2.age); //输出4--实例属性
delete animal2.age;
console.log(animal2.age); //输出3--原型属性

获取某对象属性时,首先从该对象实例本身开始,若该实例中找到该属性,则返回该属性值;若未找到,则继续查找该实例对象指向的构造函数原型对象,若找到则返回值。

(1) hasOwnProperty()方法
hasOwnProperty()方法可以检测一个属性是在原型上还是实例上,只有当给定属性为对象实例属性时返回true:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

function Animal(name) {
this.name = name;
}
Animal.prototype.age = 3;
Animal.prototype.getName = function() {
return this.name;
};
var animal1 = new Animal('Dog');
var animal2 = new Animal('Cat');
console.log(animal1.hasOwnProperty('name')); //true
console.log(animal1.hasOwnProperty('age')); //false
animal1.age = 4;
console.log(animal1.hasOwnProperty('age')); //true

(2) 原型与in
单独使用in操作符时,只要通过对象能访问到给定属性即返回true,无论属性是在实例还是原型上定义:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

function Animal(name) {
this.name = name;
}
Animal.prototype.age = 3;
Animal.prototype.getName = function() {
return this.name;
};
var animal1 = new Animal('Dog');
var animal2 = new Animal('Cat');
console.log(animal1.hasOwnProperty('name')); //true
console.log('name' in animal1); //true
console.log(animal1.hasOwnProperty('age')); //false
console.log('age' in animal1); //true
console.log('eat' in animal1); //false

实例与原型的引用关系

实例在创建时,其内部指针[[Prototype]](在上文提到的__proto__)指向构造函数原型对象,存在引用关系。

1
2
3
4
5
6
7
8
9
10

function Animal(name) {
this.name = name;
}
var animal = new Animal('Dog');
Animal.prototype.age = 3;
Animal.prototype.getName = function() {
return this.name;
};
animal.getName(); //输出Dog

可以看到虽然实例早于原型中getName方法创建,但其依然可以调用该方法,因为实例通过引用指向原型对象,原型对象变化自然能被实例访问到。然而,对于如下这种情况:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

function Animal(name) {
this.name = name;
}
var animal = new Animal('Dog');
Animal.prototype = {
constructor: Animal, //设置constructor值为Animal,确保constructor属性返回适当值,详细见上文关于constructor属性说明
age: 3,
getName: function() {

return this.name;
}
};
var animal2 = new Animal('Cat');
console.log(animal2.getName()); //输出Cat
animal.getName(); //TypeError: undefined is not a function

此处,首先创建了一个实例,随后重写了构造函数原型对象,再在实例上调用getName方法时报错;而重写构造函数原型对象之后创建的实例调用getName方法可以正常返回对应值。这是因为重写原型对象之后,之前创建的实例引用的依然是之前的原型对象,其与现有原型之间并无联系,而之后创建的实例[[Prototype]]指针引用的就是现有原型。

原型对象存在问题

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

function Animal(name) {
this.name = name;
}
Animal.prototype.age = 3;
Animal.prototype.partner = ['one'];
Animal.prototype.getName = function() {
return this.name;
};
var animal1 = new Animal('Dog');
var animal2 = new Animal('Cat');
console.log(animal1.partner); //输出["one"]
console.log(animal2.partner); //输出["one"]
animal1.partner.push('two');
console.log(animal1.partner); //输出["one", "two"]
console.log(animal2.partner); //输出["one", "two"]
console.log(animal1.partner === animal2.partner); //输出true

可以看到原型中所有属性都被实例共享,特别是对于引用类型的属性,如上的partner属性。

默认原型

所有引用类型默认都继承自Object,所有构造函数默认原型都是Object的实例,默认原型都会包含一个内部指针,指向Object.prototype。

构造函数,原型与实例的关系

每个构造函数都有一个原型对象,由prototype属性指向;原型对象包含一个指向构造函数的指针constructor;而实例都包含一个指向构造函数原型对象的内部指针[[Prototype]]。

原型链

每一个构造函数都有一个原型对象,当我们让某一原型对象等于另一构造函数的实例,此时该原型对象就包含一个指针,该指针指向这一构造函数的原型对象,该指针指向的原型对象中包含一个指向这一构造函数的指针,同样我们可以令该指针指向的原型对象等于另一构造函数的实例,如此递进,则形成一条实例与原型的链条,即原型链。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

function Parent() {
this.name = 'parent';
};
Parent.prototype.getName = function() {
return this.name;
};
function Child() {
this.childname = 'child';
}
Child.prototype = new Parent();
Child.prototype.getChildName = function() {
return this.childname;
};
var child = new Child();
console.log(child.getName()); //输出parent
console.log(child.getChildName()); //输出child

如上代码,child实例指向Child原型,Child原型等于Parent实例,即指向Parent原型。可见本质即是以一个新类型(构造函数)的实例重写原型对象,形成原型链。

原型链问题

既然原型对象存在问题,那么原型链自然也继承了这个问题,即原型属性会被所有实例共享,对于原型属性的改变将影响所有实例,而在原型链中,由于某一原型对象等于另一构造函数的实例,实例受影响,也就导致其他原型对象也受影响。

原型与原型链是JavaScript实现继承的基础,下一篇详细介绍JavaScript之继承。