我碰巧从You Don't Know JS: this & Object prototyping中学习原型，这是一本很好的书，可以理解设计的底层，澄清许多误解(这就是为什么我试图避免使用继承和instanceof之类的东西)。

但我和这里的人有同样的问题。有几个答案真的很有帮助，很有启发性。我也很乐意分享我的理解。

什么是原型?

JavaScript中的对象有一个内部属性，在规范中表示为[[Prototype]]，它只是对另一个对象的引用。几乎所有对象在创建时都会被赋予这个属性的非空值。

如何获得一个对象的原型?

通过__proto__或Object.getPrototypeOf

var a = { name: "wendi" };
a.__proto__ === Object.prototype // true
Object.getPrototypeOf(a) === Object.prototype // true

function Foo() {};
var b = new Foo();
b.__proto__ === Foo.prototype
b.__proto__.__proto__ === Object.prototype

原型是什么?

原型是作为函数的特殊属性自动创建的对象，用于建立委托(继承)链，即原型链。

当我们创建一个函数a时，prototype会自动作为a上的一个特殊属性创建，并将上的函数代码保存为prototype上的构造函数。

function Foo() {};
Foo.prototype // Object {constructor: function}
Foo.prototype.constructor === Foo // true

我想把这个属性作为存储函数对象的属性(包括方法)的地方。这也是JS中的实用函数被定义为Array.prototype.forEach()、Function.prototype.bind()、Object.prototype.toString()的原因。

为什么要强调函数的性质?

{}.prototype // undefined;
(function(){}).prototype // Object {constructor: function}

// The example above shows object does not have the prototype property.
// But we have Object.prototype, which implies an interesting fact that
typeof Object === "function"
var obj = new Object();

Arary, Function, Objectare都是函数。我必须承认，这刷新了我对JS的印象。我知道函数是JS中的一等公民，但它似乎是建立在函数之上的。

__proto__和prototype有什么区别?

__proto__a引用作用于每个对象以引用其[[Prototype]]属性。

Prototype是作为函数的特殊属性自动创建的对象，用于存储函数对象的属性(包括方法)。

有了这两个，我们可以在脑海中绘制出原型链。如图所示:

function Foo() {}
var b = new Foo();

b.__proto__ === Foo.prototype // true
Foo.__proto__ === Function.prototype // true
Function.prototype.__proto__ === Object.prototype // true

简介:

对象的__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);

'use strict'
function A() {}
var a = new A();
class B extends A {}
var b = new B();
console.log('====='); // =====
console.log(B.__proto__ === A); // true
console.log(B.prototype.__proto__ === A.prototype); // true
console.log(b.__proto__ === B.prototype); // true
console.log(a.__proto__ === A.prototype); // true
console.log(A.__proto__ === Function.__proto__); // true
console.log(Object.__proto__ === Function.__proto__); // true
console.log(Object.prototype === Function.__proto__.__proto__); // true
console.log(Object.prototype.__proto__ === null); // true

在JavaScript中，每个对象(函数也是对象!)都有__proto__属性，该属性是对其原型的引用。

当我们使用new操作符和构造函数一起创建一个新对象时， 新对象的__proto__属性将被设置为构造函数的prototype属性， 然后构造函数将由new对象调用， 在这个过程中，“this”将是构造函数作用域中对新对象的引用，最终返回新对象。

构造函数的prototype是__proto__属性，构造函数的prototype属性是work with new操作符。

构造函数必须是函数，但函数并不总是构造函数，即使它具有prototype属性。

Prototype chain实际上是对象的__proto__属性，用于引用其原型， 以及原型的__proto__属性来引用原型的原型，等等， 直到引用Object的原型的__proto__属性，该属性引用为null。

例如:

console.log(a.constructor === A); // true
// "a" don't have constructor,
// so it reference to A.prototype by its ``__proto__`` property,
// and found constructor is reference to A

[[Prototype]]和__proto__属性实际上是一样的。

我们可以使用Object的getPrototypeOf方法来获取某个对象的原型。

console.log(Object.getPrototypeOf(a) === a.__proto__); // true

我们编写的任何函数都可以用new操作符创建一个对象， 这些函数中的任何一个都可以是构造函数。

只有一个对象用于原型链接。该对象显然有一个名称和值:__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都是为原型链技术服务的。区别在于以下划线命名的函数(如__proto__)根本不是开发人员显式调用的目标。换句话说，它们只是用于继承等机制，它们是“后端”。但是不带下划线的函数是为显式调用而设计的，它们是“前端”。

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

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