使用constructor.prototype遍历原型链 [英] Traversing prototype chain using constructor.prototype

问题描述

如果我可以使用 obj.constructor.prototype 来访问对象的原型，那么为什么我不能使用 obj.constructor。 prototype.constructor.prototype 来遍历原型链并且必须使用 Object.getPrototypeOf ？

If I can use obj.constructor.prototype to access the prototype of an object, then why can't I use obj.constructor.prototype.constructor.prototype to traverse the prototype chain and have to use Object.getPrototypeOf?

function MyConstructor()
{
    this.prop = 1;
}

var o = new MyConstructor();

console.log(o.constructor.prototype) // MyConstructor

console.log(o.constructor.prototype.constructor.prototype) // MyConstructor?

不应该返回MyConstructor的原型 function [native code]} （在Chrome控制台中）？

Shouldn't it return the prototype of MyConstructor which is function() { [native code] } (in Chrome console)?

推荐答案

函数对象：

function Foo(){ this.x = 1 }; // Dummy constructor function

console.log(Foo instanceof Function) // => true; Foo is an instance of global Function constructor

所有原型都是全局 Object object：

All prototypes are instances of the global Object object:

console.log(Foo.prototype instanceof Object); // => true

定义构造函数 Foo 它自动具有附加到它的 Foo.prototype 对象，您可以将其视为一个空白对象，其本身，如上所述，继承自全局 Object 对象。换句话说， Foo.prototype 的原型是 Object.prototype ：

When a constructor Foo is defined, it automatically has a Foo.prototype object attached to it, which you can think of as a "blank" object that itself, as per the above, inherits from the global Object object. In other words, the prototype of Foo.prototype is Object.prototype:

function Foo(){ this.x = 1 }; // Dummy constructor function

console.log(Foo.prototype); // Foo (object); already exists

console.log(Object.getPrototypeOf(Foo.prototype) === Object.prototype); // => true

由于 Foo.prototype 对象，可以期望其构造函数是全局 Object 构造函数：

Since Foo.prototype is a blank object, one would expect its constructor to be the global Object constructor function:

function Foo(){ this.x = 1 }; // Dummy constructor function

console.log(Foo.prototype.constructor) // => function Foo() { this.x = 1; } ??

console.log(Foo.prototype.constructor === Object.prototype.constructor); // => false

However this "blank" object has an explicit self-referential constructor property that points back to function Foo(){ this.x = 1 } and overwrites or "masks" the default constructor property you are expecting:

function Foo(){ this.x = 1 }; // Dummy constructor function

delete Foo.prototype.constructor; // Delete explicit constructor property

console.log(Foo.prototype.constructor) // => function Object() { [native code] }

console.log(Foo.prototype.constructor === Object.prototype.constructor); // => true

因此，您不能使用 obj.constructor.prototype 递归遍历原型链并且必须依赖于 Object.getPrototypeOf（）方法。

Therefore you can't use obj.constructor.prototype recursively to traverse the prototype chain and have to rely on the Object.getPrototypeOf() method.

这是一个伟大的视觉引用。

这篇关于使用constructor.prototype遍历原型链的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！