JavaScript 对象原型以及原型链
文章目录
对象原型&原型链
1.原型 [[Prototype]]
JavaScript 中的对象有一个特殊的 [[Prototype]] 内置属性,其实就是对于其他对象的引用。几乎所有的对象在创建时 [[Prototype]] 属性都会被赋予一个非空的值。
思考一下如下代码:
var myObject = {
a:2
};
myObject.a; // 2
当你试图引用对象数据访问属性时会触发对象默认的内置[[Get]]操作,按照[[Get]]操作的算法首先从myObject对象内部查找是否有相同名称的属性,如果找到就会放回这个属性的值。
如果[[Get]]操作对象内部无法找到需要的属性,那么继续访问对象的[[prototype]]链:
let anotherObject = {
a:2
};
// 创建一个关联到 anotherObject 的对象
let myObject = Object.create( anotherObject );
myObject.a; // 2
现在 myObject 对象的 [[Prototype]] 关联到了 anotherObject。显然 myObject.a 并不存在,但是尽管如此,属性访问仍然成功地(在 anotherObject 中)找到了值 2。但是如果 anotherObject 中也找不到 a 并且 [[Prototype]] 链不为空的话,就会继续查找下去。这个过程会持续到找到匹配的属性名或者查找完整条 [[Prototype]] 链。如果是后者的话,[[Get]] 操作的返回值是 undefined。
使用 for..in 遍历对象时原理和查找 [[Prototype]] 链类似,任何可以通过原型链访问到的属性都会被枚举。使用 in 操作符来检查属性在对象中是否存在时,同样会查找对象的整条原型链(无论属性是否可枚举):
let anotherObject = {
a:2
};
// 创建一个关联到 anotherObject 的对象
let myObject = Object.create( anotherObject );
for (let k in myObject) {
console.log("found: " + k);
}
// found: a
("a" in myObject); // true
因此,当你通过各种语法进行属性查找时都会查找 [[Prototype]]链,直到找到属性或者查找完整条原型链。
Object.Prototype:
所有普通对象的[[prototype]]链指向内置的Object.Prototype。由于所有普通对象的[[prototype]]链源于Object.Prototype,所以它含有JavaScript中许多通用的功能。
属性设置和屏蔽
给一个对象设置属性并不仅仅是添加一个属性或者修改属性值,它包含以下过程:
myObject.foo = 'bar';
如果 myObject 对象中包含名为 foo 的普通数据访问属性,这条赋值语句只会修改已有的属性值
如果 foo 不是直接存在于 myObject 中,[[Prototype]] 链就会被遍历,类似 [[Get]] 操作。
如果原型链上找不到 foo,foo 就会被直接添加到 myObject 上。然而,如果 foo 存在于原型链上层,赋值语句 myObject.foo = "bar" 的行为就会有些不同。
如果属性名 foo 既出现在 myObject 中也出现在 myObject 的 [[Prototype]] 链上层,那么就会发生屏蔽。myObject 中包含的 foo 属性会屏蔽原型链上层的所有 foo 属性,因为myObject.foo 总是会选择原型链中最底层的 foo 属性。
屏蔽比我们想象中更加复杂。下面我们分析一下如果 foo 不直接存在于 myObject 中而是存在于原型链上层时 myObject.foo = "bar" 会出现的三种情况:
- 如果在 [[Prototype]] 链上层存在名为 foo 的普通数据访问属性并且没有被标记为只读(writable:false),那就会直接在 myObject 中添加一个名为 foo 的新属性,它是屏蔽属性。
- 如果在 [[Prototype]] 链上层存在 foo,但是它被标记为只读(writable:false),那么无法修改已有属性或者在 myObject 上创建屏蔽属性。如果运行在严格模式下,代码会抛出一个错误。否则,这条赋值语句会被忽略。总之,不会发生屏蔽。
- 如果在 [[Prototype]] 链上层存在 foo 并且它是一个 setter,那就一定会调用这个 setter。foo 不会被添加到(或者说屏蔽于)myObject,也不会重新定义 foo 这个 setter。
2. 构造函数
function Foo() {
// ...
}
Foo.prototype.constructor === Foo; // true
var a = new Foo();
a.constructor === Foo; // true
Foo.prototype 默认(在代码中第一行声明时!)有一个公有并且不可枚举的属性 .constructor,这个属性引用的是对象关联的函数 Foo。此外,我们可以看到通过“构造函数”调用 new Foo() 创建的对象也有一个 .constructor 属性,指向“创建这个对象的函数”
function NothingSpecial() {
console.log( "Don't mind me!" );
}
var a = new NothingSpecial();//Don't mind me!
let b = NothingSpecial();//Don't mind me!
console.log(a)//NothingSpecial{}
console.log(b)//undefined
NothingSpecial 其实是一个普通函数,但通过使用new调用的时候,它就会构造出一个对象并且赋给 a。这里的调用只是构造函数调用,但是NothingSpecial本身并不是一个构造函数。
3. 检查原型关系
(1)instanceof:
function Foo() {
// ...
}
var a = new Foo();
console.log(a instanceof Foo) //true
instanceof 操作符的左操作数是一个普通的对象,右操作数是一个函数。instanceof 回答的问题是:在 a 的整条 [[Prototype]] 链中是否有指向 Foo.prototype 的对象?可惜,这个方法只能处理对象(a)和函数(带 .prototype 引用的 Foo)之间的关系。如果你想判断两个对象(比如 a 和 b)之间是否通过 [[Prototype]] 链关联,只用 instanceof无法实现。
(2)isPrototypeOf:
let a = {
x:1
}
let b = Object.create(a);
let c = {
y:2
};
console.log(a.isPrototypeOf(b));//true
console.log(c.isPrototypeOf(b));//false
isPrototypeOf是用来判断指定对象a是否存在于另一个对象b的原型链中,是则返回true,否则返回false。
(3)Object.getPrototypeOf(对象):
function Foo(){
//...
}
let a = new Foo();
let b = {
x:1
}
console.log(Object.getPrototypeOf(a) == Foo.prototype);//true
console.log(Object.getPrototypeOf(b) == Foo.prototype);//false
Object.getPrototypeOf(对象)可以获取对象的[[prototype]]链
(4) proto :
function Foo(){
//...
}
let a = new Foo();
console.log(a.__proto__);
console.log(Foo.prototype);
console.log(Foo.prototype.__proto__);
console.log(Object.prototype);
console.log(Object.prototype.__proto__);
输出结果:

function Foo(){
//...
}
let a = new Foo();
let c = {
x:1
}
console.log(a.__proto__ === Object.prototype);//false
console.log(a.__proto__ === Foo.prototype);//true
console.log(Foo.prototype.__proto__ === Object.prototype);//true
console.log(c.__proto__ === Object.prototype);//true
proto 返回对象上一层[[prototype]]原型对象
4. 总结
如果要访问对象中并不存在的一个属性,[[Get]] 操作就会查找对象内部[[Prototype]] 关联的对象。这个关联关系实际上定义了一条“原型链”(有点像嵌套的作用域链),在查找属性时会对它进行遍历。
所有普通对象都有内置的 Object.prototype,指向原型链的顶端(比如说全局作用域),如果在原型链中找不到指定的属性就会停止。toString()、valueOf() 和其他一些通用的功能都存在于 Object.prototype 对象上,因此语言中所有的对象都可以使用它们。
关联两个对象最常用的方法是使用 new 关键词进行函数调用中会创建一个关联其他对象的新对象。使用 new 调用函数时会把新对象的 .prototype 属性关联到“其他对象”。带 new 的函数调用通常被称为“构造函数调用”,尽管它们实际上和传统面向类语言中的类构造函数不一样。
虽然这些 JavaScript 机制和传统面向类语言中的“类初始化”和“类继承”很相似,但是 JavaScript 中的机制有一个核心区别,那就是不会进行复制,对象之间是通过内部的[[Prototype]] 链关联的。
出于各种原因,以“继承”结尾的术语(包括“原型继承”)和其他面向对象的术语都无法帮助你理解 JavaScript 的真实机制(不仅仅是限制我们的思维模式)。相比之下,“委托”是一个更合适的术语,因为对象之间的关系不是复制而是委托。

评论
登录后参与技术讨论,分享你的经验与见解。
登录 / 注册暂无评论