首先这里有几个重要的知识点，我从网上摘录来的。而这几个重要的知识点将是我们正确理解Javascript中的__proto__和prototype关系、以及原型链的关键。

       1、对象有属性__proto__,指向该对象的构造函数的原型对象

       2、方法除了有属性__proto__,还有属性prototype，prototype指向该方法的原型对象。

       3、首先，并不是所有的对象都有prototype属性，只有函数对象才有prototype属性。其次，所有的对象都有__proto__的内部属性，指向构造函数的prototype，即原型， 对象在调用一个方法时会首先在自身里寻找是否有该方法，若没有，则通过内部的__proto__属性去自己的构造函数原型上去寻找，依次层层递进，直到Object.prototype.__proto__=null为止，这样往上追溯的整个过程，即原型链。


参考：​​js中__proto__和prototype的区别和关系？​​​         ​​理解js中的原型链，prototype与__proto__的关系​​


作者：苏墨橘
__proto__（隐式原型）与prototype（显式原型）

1.是什么

  • 显式原型 explicit prototype property：

每一个函数在创建之后都会拥有一个名为prototype的属性，这个属性指向函数的原型对象。

Note：通过Function.prototype.bind方法构造出来的函数是个例外，它没有prototype属性。（感谢 ​​ @陈禹鲁​​ 同学的答案让我知道这一点）



NOTE Function objects created using Function.prototype.bind do not have a prototype property or the [[Code]], [[FormalParameters]], and [[Scope]] internal properties. -----

  • 隐式原型 implicit prototype link：

JavaScript中任意对象都有一个内置属性[[prototype]]，在ES5之前没有标准的方法访问这个内置属性，但是大多数浏览器都支持通过__proto__来访问。ES5中有了对于这个内置属性标准的Get方法Object.getPrototypeOf().

Note: Object.prototype 这个对象是个例外，它的__proto__值为null



  • 二者的关系：

隐式原型指向创建这个对象的函数(constructor)的prototype


2. 作用是什么



  • 显式原型的作用：用来实现基于原型的继承与属性的共享。

ECMAScript does not use classes such as those in C++, Smalltalk, or Java. Instead objects may be created in various ways including via a literal notation or via constructors which create objects and then execute code that initialises all or part of them by assigning initial values to their properties. Each constructor is a function that has a property named “prototype” that is used to implement prototype-based inheritance and shared properties.Objects are created by using constructors in new expressions; for example, new Date(2009,11) creates a new Date object. ----​​ECMAScript Language Specification​​

  • 隐式原型的作用：构成原型链，同样用于实现基于原型的继承。举个例子，当我们访问obj这个对象中的x属性时，如果在obj中找不到，那么就会沿着__proto__依次查找。

Every object created by a constructor has an implicit reference (called the object’s prototype) to the value of its constructor’s “prototype” ----​​ECMAScript Language Specification​​



3. __proto__的指向

__proto__的指向到底如何判断呢？根据ECMA定义 'to the value of its constructor’s "prototype" ' ----指向创建这个对象的函数的显式原型。所以关键的点在于找到创建这个对象的构造函数，接下来就来看一下JS中对象被创建的方式，一眼看过去似乎有三种方式：（1）对象字面量的方式 （2）new 的方式 （3）ES5中的Object.create() 但是我认为本质上只有一种方式，也就是通过new来创建。为什么这么说呢，首先字面量的方式是一种为了开发人员更方便创建对象的一个语法糖，本质就是 var o = new Object(); o.xx = xx;o.yy=yy; 再来看看Object.create(),这是ES5中新增的方法，在这之前这被称为原型式继承，



道格拉斯在2006年写了一篇文章，题为 Prototypal Inheritance In JavaScript。在这篇文章中，他介绍了一种实现继承的方法，这种方法并没有使用严格意义上的构造函数。他的想法是借助原型可以基于已有的对象创建新对象，同时还不比因此创建自定义类型，为了达到这个目的，他给出了如下函数: 



function object(o){
    function F(){}
    F.prototype = o;
    return new F()
}



----- 《JavaScript高级程序设计》P169



所以从实现代码 return new F() 中我们可以看到，这依然是通过new来创建的。不同之处在于由 Object.create() 创建出来的对象没有构造函数，看到这里你是不是要问，没有构造函数我怎么知道它的__proto__指向哪里呢，其实这里说它没有构造函数是指在 Object.create() 函数外部我们不能访问到它的构造函数，然而在函数内部实现中是有的，它短暂地存在了那么一会儿。假设我们现在就在函数内部，可以看到对象的构造函数是F, 现在



//以下是用于验证的伪代码
var f = new F(); 
//于是有
f.__proto__ === F.prototype //true
//又因为
F.prototype === o;//true
//所以
f.__proto__ === o;


因此由Object.create(o)创建出来的对象它的隐式原型指向o。好了，对象的创建方式分析完了，现在你应该能够判断一个对象的__proto__指向谁了。


好吧，还是举一些一眼看过去比较疑惑的例子来巩固一下。




  • 构造函数的显示原型的隐式原型：
  1. 内建对象(built-in object)：比如Array()，Array.prototype.__proto__指向什么？Array.prototype也是一个对象，对象就是由 Object() 这个构造函数创建的，因此Array.prototype.__proto__ === Object.prototype //true，或者也可以这么理解，所有的内建对象都是由Object()创建而来。
  • 自定义对象

1. 默认情况下：



function Foo(){}
var foo = new Foo()
Foo.prototype.__proto__ === Object.prototype //true 理由同上


2. 其他情况：

（1）



function Bar(){}
//这时我们想让Foo继承Bar
Foo.prototype = new Bar()
 Foo.prototype.__proto__ === Bar.prototype //true


（2）



//我们不想让Foo继承谁，但是我们要自己重新定义Foo.prototype
Foo.prototype = {
  a:10,
  b:-10
}
//这种方式就是用了对象字面量的方式来创建一个对象，根据前文所述 
Foo.prototype.__proto__ === Object.prototype


注： 以上两种情况都等于完全重写了Foo.prototype，所以Foo.prototype.constructor也跟着改变了，于是乎constructor这个属性和原来的构造函数Foo（）也就切断了联系。




  • 构造函数的隐式原型

既然是构造函数那么它就是Function（）的实例，因此也就指向Function.prototype,比如 Object.__proto__ === Function.prototype


4. instanceofinstanceof 操作符的内部实现机制和隐式原型、显式原型有直接的关系。instanceof的左值一般是一个对象，右值一般是一个构造函数，用来判断左值是否是右值的实例。它的内部实现原理是这样的： 



//设 L instanceof R 
//通过判断
 L.__proto__.__proto__ ..... === R.prototype ？
//最终返回true or false


也就是沿着L的__proto__一直寻找到原型链末端，直到等于R.prototype为止。知道了这个也就知道为什么以下这些奇怪的表达式为什么会得到相应的值了



Function instanceof Object // true 
 Object instanceof Function // true 
 Function instanceof Function //true
 Object instanceof Object // true
 Number instanceof Number //false

文章参考：

​​JavaScript instanceof 运算符深入剖析​​



理解js中的原型链，prototype与__proto__的关系

说到prototype，就不得不先说下new的过程。

我们先看看这样一段代码：


1 <script type="text/javascript">
2 var Person = function () { };
3 var p = new Person();
4 </script>


很简单的一段代码，我们来看看这个new究竟做了什么？我们可以把new的过程拆分成以下三步：

<1> var p={}; 也就是说，初始化一个对象p。

<2> p.__proto__=Person.prototype;

<3> Person.call(p);也就是说构造p，也可以称之为初始化p。

关键在于第二步，我们来证明一下：

1 <script type="text/javascript">
2 var Person = function () { };
3 var p = new Person();
4 alert(p.__proto__ === Person.prototype);
5 </script>

这段代码会返回true。说明我们步骤2的正确。

那么__proto__是什么？我们在这里简单地说下。每个对象都会在其内部初始化一个属性，就是__proto__，当我们访问一个对象的属性 时，如果这个对象内部不存在这个属性，那么他就会去__proto__里找这个属性，这个__proto__又会有自己的__proto__，于是就这样 一直找下去，也就是我们平时所说的原型链的概念。

按照标准，__proto__是不对外公开的，也就是说是个私有属性，但是Firefox的引擎将他暴露了出来成为了一个共有的属性，我们可以对外访问和设置。

好，概念说清了，让我们看一下下面这些代码：

1 <script type="text/javascript">
2 var Person = function () { };
3 Person.prototype.Say = function () {
4 alert("Person say");
5 }
6 var p = new Person();
7 p.Say();
8 </script>

这段代码很简单，相信每个人都这样写过，那就让我们看下为什么p可以访问Person的Say。

首先var p=new Person()；可以得出p.__proto__=Person.prototype。那么当我们调用p.Say()时，首先p中没有Say这个属性， 于是，他就需要到他的__proto__中去找，也就是Person.prototype，而我们在上面定义了 Person.prototype.Say=function(){}; 于是，就找到了这个方法。

好，接下来，让我们看个更复杂的。

01  <script type="text/javascript">
02  var Person = function () { };
03  Person.prototype.Say = function () {
04  alert("Person say");
05  }
06  Person.prototype.Salary = 50000;
 

07  var Programmer = function () { };
08  Programmer.prototype = new Person();
09  Programmer.prototype.WriteCode = function () {
10  alert("programmer writes code");
11  };
 

12  Programmer.prototype.Salary = 500;
 

13  var p = new Programmer();
14  p.Say();
15  p.WriteCode();
16  alert(p.Salary);
17  </script>

我们来做这样的推导：

var p=new Programmer()可以得出p.__proto__=Programmer.prototype;

而在上面我们指定了Programmer.prototype=new Person();我们来这样拆分，var p1=new Person();Programmer.prototype=p1;那么:

p1.__proto__=Person.prototype;

Programmer.prototype.__proto__=Person.prototype;

由根据上面得到p.__proto__=Programmer.prototype。可以得到p.__proto__.__proto__=Person.prototype。

好，算清楚了之后我们来看上面的结果,p.Say()。由于p没有Say这个属性，于是去p.__proto__，也就是 Programmer.prototype，也就是p1中去找，由于p1中也没有Say，那就去p.__proto__.__proto__，也就是 Person.prototype中去找，于是就找到了alert(“Person say”)的方法。

其余的也都是同样的道理。

这也就是原型链的实现原理。

最后，其实prototype只是一个假象，他在实现原型链中只是起到了一个辅助作用，换句话说，他只是在new的时候有着一定的价值，而原型链的本质，其实在于__proto__！