Javascript __proto__ – 澄清？

我有这个功能：

function Foo(){}

根据这张图片：

>> Foo.prototype   ->    Foo {}

所以,如果我写：

Foo.prototype.constructor

现在 – 它引用了构造函数,它创建了Foo {}对象,它是函数Foo(){}

一切都好.

那问题在哪里？

Foo.prototype是一个对象实例 – > Foo {}

谁是Foo {}的构造函数？

它是函数Foo(){}

你可以在这里看到黄色：

好

但有人告诉我here：

所以Foo.prototype .__ proto__应该引用函数Foo(){}的原型而不是Object.prototype！

如果我翻译它：

    __proto__               is the                   ctor's                        prototype
    _________________________________________________________________________________________
  Foo.prototype.__proto__     is the               function Foo(){}               Foo.prototype

但这是错误的

我可能错了,因为：

我错过了什么？

最佳答案

注意：首先,__ proto__是非标准的,使用Object.getPrototypeOf,虽然为了简洁,因为我很懒,我在这个答案中确实使用了原型很多次

好吧,如果我正确地读你,你会被最初的假设所抛弃：

Foo.prototype -> Foo{}

根据定义,Foo的原型(它是一个构造函数)是Foo的一个实例.但是,因为构造函数是一个函数,并且构造函数返回特定实例的对象,所以原型将是一个增强的对象.
我不是将原型无效性与经典OOP进行比较的忠实粉丝,但是想到这样：

Foo原型是一种可变类定义(您可以随意添加方法和属性),构造函数创建一个对象来扩充此原型,并在实例级别添加另一层属性/方法.
因此Foo.prototype instanceof Foo是真的.但是,Foo是一个对象：

Object.getPrototypeOf(Foo.prototype) === Object.prototype

是真的.就像

Object.getPrototypeOf(Array.prototype) === Object.prototype.

把它翻译成JS(原型)-speak,你会得到类似的东西：

对于JS创建的每个函数对象,为该对象分配一个prototype属性. prototype属性是Object的一个实例,但它有一个特殊属性.
如果有人试图访问对象上的属性或方法,并且JS无法在实例级别找到此属性,JS将尝试解析prototype属性上的名称：

instance.nonExistantProperty;
//js scans instance variable,doesn't find property:
instance.prototype.nonExistantProperty
//js uses prototype,if not found:
instance.prototype.prototype.nonExistantProperty
//all the way up to Object.prototype,which does not have a prototype,so here an exception is raised (TypeError is thrown)

这是我从one of my older posts here复制的查找的简短示意图,可能值得一看,也检查底部的链接答案,他们会详细介绍这个问题

[      F.divide      ]<=========================================================\ \
F[divide] ===> JS checks instance for property divide                           | |
 /\ ||                                                                          | |
 || || --> property found @instance,return value-------------------------------| |
 || ||                                                                          | |
 || ===========> Function.prototype.divide could not be found,check prototype  | |
 ||      ||                                                                     | |
 ||      ||--> property found @Function.prototype,return-----------------------| |
 ||      ||                                                                     | |
 ||      ==========> Object.prototype.divide: not found check prototype?        | |
 ||          ||                                                                 | |
 ||          ||--> property found @Object.prototype,return---------------------|_|
 ||          ||                                                                 |=|
 ||          =======>prototype is null,return "undefined.divide"~~~~~~~~~~~~~~~|X|
 ||                                                                             \ /
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~< TypeError can't read property 'x' of undefined

基本上就是这样.

现在,也许你对于为什么Foo.prototype.constructor引用Foo函数有点挫败.
同样,这很容易,因为每个实例都应包含您可能需要的所有信息,以确定您正在处理的对象类型：

function Foo{}
var inst = new Foo();
console.log(inst.constructor);//references the constructor function

请记住,Foo返回的所有实例都返回一个对象,该对象引用所有原型属性,以及(可选)实例级别的某些属性.

那么,为什么还要打扰创建这样的实例呢？同样,这非常简单：更改实例,不会更改原型：

console.log(Foo.prototype.constructor === inst.constructor);//true
inst.constructor = function(){};//override constructor property
console.log(Foo.prototype.constructor === inst.constructor);//false,prototype did not change