我知道，我迟到了，但让我试着简化一下。

假设有一个函数

    function Foo(message){

         this.message = message ; 
     };

     console.log(Foo.prototype);

Foo函数将有一个原型对象链接。所以，无论何时我们在JavaScript中创建一个函数，它总是有一个原型对象链接到它。

现在让我们继续使用函数Foo创建两个对象。

    var a = new Foo("a");
    var b = new Foo("b");
    console.log(a.message);
    console.log(b.message);

现在我们有两个对象，对象a和对象b。它们都被创建了 使用构造函数Foo。记住，构造函数在这里只是一个词。 对象a和b都有message属性的副本。 这两个对象a和b链接到构造函数Foo的原型对象。 在对象a和b上，我们可以在所有浏览器中使用__proto__属性访问Foo prototype，在IE中我们可以使用Object.getPrototypeOf(a)或Object.getPrototypeOf(b)

现在,Foo。Prototype, a.__proto__和b.__proto__都表示同一个对象。

    b.__proto__ === Object.getPrototypeOf(a);
    a.__proto__ ===  Foo.prototype;
    a.constructor.prototype  === a.__proto__;

所有这些都将返回true。

如我们所知，在JavaScript中属性可以动态添加。我们可以向对象添加属性

    Foo.prototype.Greet = function(){

         console.log(this.message);
    }
    a.Greet();//a
    b.Greet();//b
    a.constructor.prototype.Greet();//undefined 

如你所见，我们在Foo中添加了Greet()方法。但它可以在a和b或任何其他使用Foo构造的对象中访问。

在执行a.Greet()时，JavaScript将首先在对象a的属性列表中搜索Greet。如果没有找到，它将在a. Since a.__proto__和Foo的__proto__链中上升。prototype是同一个对象，JavaScript会找到Greet()方法并执行它。

我希望，现在prototype和__proto__被简化了一点。

我为自己画了一个小图，代表以下代码片段:

var Cat = function() {}
var tom = new Cat()

我有经典的OO背景，所以用这种方式表示层次结构很有帮助。为了帮助您阅读此图表，请将图像中的矩形视为JavaScript对象。是的，函数也是对象。；）

JavaScript中的对象有属性，__proto__只是其中之一。

此属性背后的思想是指向(继承)层次结构中的祖先对象。

JavaScript的根对象是object。Prototype和所有其他对象都是这个对象的后代。根对象的__proto__属性为null，表示继承链的结束。

你会注意到原型是函数的属性。Cat是一个函数，但function和Object也是(本机)函数。Tom不是一个函数，因此它没有这个属性。

此属性背后的思想是指向一个将在构造中使用的对象，即当您在该函数上调用new操作符时。

注意，原型对象(黄色矩形)有另一个属性称为 构造函数，它指向各自的函数对象。为 简短的原因，这是没有描述。

实际上，当我们用new Cat()创建tom对象时，所创建的对象的__proto__属性将被设置为构造函数的原型对象。

最后，让我们稍微研究一下这个图表。以下陈述是正确的:

汤姆。__proto__属性指向与Cat.prototype相同的对象。 猫。__proto__指向函数。原型对象，就像函数一样。__proto__和Object。__proto__做。 Cat.prototype。__proto__和tom.__proto__。__proto__指向相同的对象，即object .prototype。

干杯!

这个问题有很多很好的答案，但为了概括和紧凑形式的答案，我添加了以下内容:

我们必须考虑的第一件事是，当JS发明的时候，计算机的内存非常低，所以如果我们需要一个进程来创建新的对象类型，我们必须考虑内存性能。

因此，他们在内存的独立部分，定位由特定对象类型创建的对象需要的方法，而不是每次我们创建一个新对象时，在对象之外存储方法。 因此，如果我们用JS的新特性重新定义新的运算符和构造函数概念，我们有以下步骤:

和空对象。(这将是对象类型实例化的最终结果)

let empty={}

我们已经知道，由于内存性能原因，对象类型实例所需的所有方法都位于构造函数的prototype属性上。(函数也是对象，所以它们可以有属性) 因此，我们将空对象的__protp__引用到这些方法存在的位置。 (我们将概念上作为构造函数使用的函数命名为构造函数。

empty.__proto__ = constructor.prototype

我们必须初始化对象类型值。 在JS中的函数与对象断开连接。使用点表示法或函数对象的bind call apply等方法，我们必须知道“函数的上下文是什么”。

let newFunc = constructor.bind(empty)

现在我们有了一个新函数，它有一个空对象作为这个context。 执行此函数后。空对象将被填充，如果定义的构造函数函数没有返回，类型object的实例化结果将是这个空对象(就好像这将是该过程的结果一样)

所以正如你所看到的，__proto__是一个对象的属性，它引用了其他对象(在JS中函数也是对象)原型对象属性，它由跨特定对象类型的实例使用的属性组成。

正如你可以从短语中猜到的那样，函数是对象，函数也有__proto__属性，因此它们可以引用其他对象的prototype属性。这就是原型继承的实现方式。

我知道，我迟到了，但让我试着简化一下。

假设有一个函数

    function Foo(message){

         this.message = message ; 
     };

     console.log(Foo.prototype);

Foo函数将有一个原型对象链接。所以，无论何时我们在JavaScript中创建一个函数，它总是有一个原型对象链接到它。

现在让我们继续使用函数Foo创建两个对象。

    var a = new Foo("a");
    var b = new Foo("b");
    console.log(a.message);
    console.log(b.message);

现在我们有两个对象，对象a和对象b。它们都被创建了 使用构造函数Foo。记住，构造函数在这里只是一个词。 对象a和b都有message属性的副本。 这两个对象a和b链接到构造函数Foo的原型对象。 在对象a和b上，我们可以在所有浏览器中使用__proto__属性访问Foo prototype，在IE中我们可以使用Object.getPrototypeOf(a)或Object.getPrototypeOf(b)

现在,Foo。Prototype, a.__proto__和b.__proto__都表示同一个对象。

    b.__proto__ === Object.getPrototypeOf(a);
    a.__proto__ ===  Foo.prototype;
    a.constructor.prototype  === a.__proto__;

所有这些都将返回true。

如我们所知，在JavaScript中属性可以动态添加。我们可以向对象添加属性

    Foo.prototype.Greet = function(){

         console.log(this.message);
    }
    a.Greet();//a
    b.Greet();//b
    a.constructor.prototype.Greet();//undefined 

如你所见，我们在Foo中添加了Greet()方法。但它可以在a和b或任何其他使用Foo构造的对象中访问。

在执行a.Greet()时，JavaScript将首先在对象a的属性列表中搜索Greet。如果没有找到，它将在a. Since a.__proto__和Foo的__proto__链中上升。prototype是同一个对象，JavaScript会找到Greet()方法并执行它。

我希望，现在prototype和__proto__被简化了一点。

对于静态方法使用__proto__怎么样?

function Foo(name){
  this.name = name
  Foo.__proto__.collection.push(this)
  Foo.__proto__.count++

}

Foo.__proto__.count=0
Foo.__proto__.collection=[]

var bar = new Foo('bar')
var baz = new Foo('baz')

Foo.count;//2
Foo.collection // [{...}, {...}]
bar.count // undefined

我认为你需要知道__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代替。