__proto__是在类/函数的实例创建时创建的。基本上，它包含创建实例的类/函数的原型。 原型包含可以被链接的实际原型。

定义

(括号()内的数字是一个“链接”到下面写的代码)

原型-一个对象，包括: =>函数(3) prototype(5) 通过此构造函数(1)创建或将创建的对象(4) =>构造函数本身(1) =>此特定对象的__proto__ (prototype对象)

__proto__ (dandor prototype ?) -通过特定构造函数(1)创建的任何对象(2)和该构造函数的原型对象的属性(5)之间的链接，允许每个创建的对象(2)访问原型的函数和方法(4)(__proto__默认包含在JS中的每个对象中)

代码说明

1.

    function Person (name, age) {
        this.name = name;
        this.age = age;  

    } 

2.

    var John = new Person(‘John’, 37);
    // John is an object

3.

    Person.prototype.getOlder = function() {
        this.age++;
    }
    // getOlder is a key that has a value of the function

4.

    John.getOlder();

5.

    Person.prototype;

简介:

对象的__proto__属性是映射到该对象的构造函数原型的属性。换句话说:

实例。__proto__ ===构造函数。原型// true

这用于形成对象的原型链。原型链是一个对象属性的查找机制。如果访问对象的属性，JavaScript将首先查看对象本身。如果属性在那里没有找到，它将一路攀升到原链，直到它被找到(或没有)

例子:

人(姓名、城市){ This.name = name; ｝ Person.prototype.age = 25; const willem =新人(' willem '); console.log(威廉。__proto__ === Person.prototype);//实例上的__proto__属性指向构造函数的原型 console.log (willem.age);// 25没有在willem object中找到它，但在prototype中存在 console.log (willem.__proto__.age);//现在我们直接访问Person函数的原型

第一个日志的结果为true，这是因为构造函数创建的实例的__proto__属性引用了构造函数的prototype属性。记住，在JavaScript中，函数也是对象。对象可以有属性，任何函数的默认属性都是一个名为prototype的属性。

然后，当这个函数被用作构造函数时，从它实例化的对象将接收一个名为__proto__的属性。这个__proto__属性引用了构造函数的prototype属性(默认情况下每个函数都有)。

为什么这个有用?

JavaScript在查找对象属性时有一种叫做“原型继承”的机制，下面是它的基本功能:

First, it's checked if the property is located on the Object itself. If so, this property is returned. If the property is not located on the object itself, it will 'climb up the protochain'. It basically looks at the object referred to by the __proto__ property. There, it checks if the property is available on the object referred to by __proto__. If the property isn't located on the __proto__ object, it will climb up the __proto__ chain, all the way up to Object object. If it cannot find the property anywhere on the object and its prototype chain, it will return undefined.

例如:

人(名){ This.name = name; ｝ let mySelf =新人(“威廉”); console.log(我自己。__proto__ === Person.prototype); console.log (mySelf.__proto__。__proto__ === Object.prototype);

我认为你需要知道__proto__， [[prototype]]和prototype之间的区别。

公认的答案是有帮助的，但它可能暗示(不完全)__proto__只与在构造函数上使用new创建的对象相关，这是不正确的。

更准确地说:__proto__存在于每个对象上。

But what is __proto__ at all? Well, it is an object referencing another object which is also a property of all objects, called [[prototype]]. It's worth mentioning that [[prototype]] is something that JavaScript handles internally and is inaccessible to the developer. Why would we need a reference object to the property [[prototype]] (of all objects)? Because JavaScript doesn't want to allow getting / setting the [[prototype]] directly, so it allows it through a middle layer which is __proto__. So you can think of __proto__ as a getter/setter of the [[prototype]] property. What is prototype then? It is something specific to functions(Initially defined in Function, i.e, Function.prototype and then prototypically inherited by newly created functions, and then again those functions give it to their children, forming a chain of prototypical inheritance). JavaScript uses a parent function's prototype to set its child functions' [[prototype]] when that parent function is run with new (remember we said all objects have [[prototype]]? well, functions are objects too, so they have [[prototype]] as well). So when the [[prototype]] of a function(child) is set to the prototype of another function(parent), you will have this in the end: let child = new Parent(); child.__proto__ === Parent.prototype // --> true. (Remember child.[[prototype]] is inaccessible, so we checked it using __proto__.)

注意1:只要属性不在子对象中，它的__proto__将被“隐式”搜索。例如，if child。Myprop返回一个值，你不能说" Myprop "是子对象的属性，还是父对象原型的属性。这也意味着你永远不需要做这样的事情:child.__proto__.__proto__。我的东西你自己拿去吧，孩子。Myprop会自动为你做这件事。

注意2:即使父对象的原型中有项目，子对象自己的原型最初也是一个空对象。如果您想进一步扩展继承链(将child[ren]添加到child)，则可以向其中添加项或手动从其中删除项。或者可以隐式地操纵它，例如使用类语法。)

注意3:如果你需要自己设置/获取[[prototype]]，使用__proto__有点过时，现代JavaScript建议使用Object。setPrototypeOf和Object。getPrototypeOf代替。

只有一个对象用于原型链接。该对象显然有一个名称和值:__proto__是它的名称，prototype是它的值。这是所有。

为了让它更容易理解，看看这篇文章顶部的图表(由dmitry soshnikov绘制的图表)，你永远不会发现__proto__的值指向prototype以外的其他东西。

要点是:__proto__是引用原型对象的名称，prototype是实际的原型对象。

这就像是在说:

let x = {name: 'john'};

X是对象名称(指针)，{name: 'john'}是实际对象(数据值)。

注意:这只是一个非常简单的提示，说明它们在较高的水平上是如何相互关联的。

更新:下面是一个简单具体的javascript示例，以便更好地说明:

let x = new String("testing") // Or any other javascript object you want to create

Object.getPrototypeOf(x) === x.__proto__; // true

这意味着当Object.getPrototypeOf(x)为我们获取x的实际值(这是它的原型)时，正是x的__proto__所指向的。因此__proto__确实指向x的原型。因此__proto__引用x (x的指针)，而prototype是x的值(它的原型)。

我希望现在大家都明白了。

__proto__是在查找链中用于解析方法的实际对象，prototype是在你用new创建对象时用于构建__proto__的对象:

( new Foo ).__proto__ === Foo.prototype
( new Foo ).prototype === undefined