一 prototype介绍
prototype对象是实现面向对象的一个重要机制。每个函数也是一个对象，它们对应的类就是function，每个函数对象都具有一个子对象prototype。Prototype 表示了该函数的原型，prototype表示了一个类的属性的集合。当通过new来生成一个类的对象时，prototype对象的属性就会成为实例化对象的属性。
下面以一个例子来介绍prototype的应用，代码如下：
<script language="javascript"> //定义一个空类 function HelloClass(){ } //对类的prototype对象进行修改，增加方法method HelloClass.prototype.method=function(){ alert("prototype测试"); } var obj=new HelloClass(); //创建类HelloClass的实例 obj.method(); //调用obj的<a href="https://www.baidu.com/s?wd=method%E6%96%B9%E6%B3%95&tn=44039180_cpr&fenlei=mv6quAkxTZn0IZRqIHckPjms" target="_blank" class="baidu-highlight">method方法</a> </script>
当用new创建一个对象时，prototype对象的属性将自动赋给所创建的对象，例如：
<script language="javascript"> //定义一个只有一个属性的类 function HelloClass(){ this.name="javakc"; } //使用函数的prototype属性给类定义新属性 HelloClass.prototype.showName=function(){ alert(this.name); } var obj=new HelloClass(); //创建类HelloClass的一个实例 //调用通过prototype原型对象定义的showName方法 obj.showName(); </script>
二 利用prototype实现继承
<script language="javascript"> function HelloClass(){ //构造方法 } function HelloSubClass(){ //构造方法 } HelloSubClass.prototype=HelloClass.prototype; HelloSubClass.prototype.Propertys="name"; HelloSubClass.prototype.subMethods=function(){ //方法实现代码 alert("in Methods"); } var obj=new HelloSubClass(); obj.subMethods(); </script>
在以上的代码中，首先是HelloSubClass具有了和HelloClass一样的prototype，如果不考虑构造方法，则两个类是等价的。随后，又通过prototype给HelloSubClass赋予了额外的属性和方法,所以HelloSubClass是在HelloClass的基础上增加了新的属性和方法，从而实现了类的继承。
三 看一张图
首先，要明确几个点：
1.在JS里，万物皆对象。方法（Function）是对象，方法的原型(Function.prototype)是对象。因此，它们都会具有对象共有的特点。即：对象具有属性__proto__，可称为隐式原型，一个对象的隐式原型指向构造该对象的构造函数的原型，这也保证了实例能够访问在构造函数原型中定义的属性和方法。
2.方法(Function)方法这个特殊的对象，除了和其他对象一样有上述_proto_属性之外，还有自己特有的属性——原型属性（prototype），这个属性是一个指针，指向一个对象，这个对象的用途就是包含所有实例共享的属性和方法（我们把这个对象叫做原型对象）。原型对象也有一个属性，叫做constructor，这个属性包含了一个指针，指回原构造函数。
好啦，知道了这两个基本点，我们来看看上面这副图。
1.构造函数Foo()构造函数的原型属性Foo.prototype指向了原型对象，在原型对象里有共有的方法，所有构造函数声明的实例（这里是f1，f2）都可以共享这个方法。
2.原型对象Foo.prototypeFoo.prototype保存着实例共享的方法，有一个指针constructor指回构造函数。
3.实例f1和f2是Foo这个对象的两个实例，这两个对象也有属性__proto__，指向构造函数的原型对象，这样子就可以像上面1所说的访问原型对象的所有方法啦。
另外：构造函数Foo()除了是方法，也是对象啊，它也有__proto__属性，指向谁呢？指向它的构造函数的原型对象呗。函数的构造函数不就是Function嘛，因此这里的__proto__指向了Function.prototype。其实除了Foo()，Function(), Object()也是一样的道理。
原型对象也是对象啊，它的__proto__属性，又指向谁呢？同理，指向它的构造函数的原型对象呗。这里是Object.prototype.最后，Object.prototype的__proto__属性指向null。
总结：
1.对象有属性__proto__,指向该对象的构造函数的原型对象。
2.方法除了有属性__proto__,还有属性prototype，prototype指向该方法的原型对象。
四 __proto__（隐式原型）与prototype（显式原型）
1.是什么
显式原型 explicit prototype property：
每一个函数在创建之后都会拥有一个名为prototype的属性，这个属性指向函数的原型对象。Note：通过Function.prototype.bind方法构造出来的函数是个例外，它没有prototype属性。
隐式原型 implicit prototype link：
JavaScript中任意对象都有一个内置属性[[prototype]]，在ES5之前没有标准的方法访问这个内置属性，但是大多数浏览器都支持通过__proto__来访问。ES5中有了对于这个内置属性标准的Get方法Object.getPrototypeOf().
Note: Object.prototype 这个对象是个例外，它的__proto__值为null，二者的关系：隐式原型指向创建这个对象的函数(constructor)的prototype
显式原型的作用：用来实现基于原型的继承与属性的共享。
隐式原型的作用：构成原型链，同样用于实现基于原型的继承。举个例子，当我们访问obj这个对象中的x属性时，如果在obj中找不到，那么就会沿着__proto__依次查找。
__proto__的指向到底如何判断呢？根据ECMA定义 'to the value of its constructor’s "prototype" ' ----指向创建这个对象的函数的显式原型。所以关键的点在于找到创建这个对象的构造函数，接下来就来看一下JS中对象被创建的方式，一眼看过去似乎有三种方式：
道格拉斯在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__指向谁了。
好吧，还是举一些一眼看过去比较疑惑的例子来巩固一下。
构造函数的显示原型的隐式原型：
内建对象(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. 其他情况：
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
instanceof 操作符的内部实现机制和隐式原型、显式原型有直接的关系。instanceof的左值一般是一个对象，右值一般是一个构造函数，用来判断左值是否是右值的实例。它的内部实现原理是这样的：
//设 L instanceof R //通过判断 L.__proto__.__proto__ ..... === R.prototype ？ //最终返回true or false
Function instanceof Object // true Object instanceof Function // true Function instanceof Function //true Object instanceof Object // true Number instanceof Number //false
五 构建对象方法：
构造对象的方法:
1.这个对象是通过对象字面量构造出来的：
var person1={ name:'shaw', age:'30' }
形如上面的形式叫着对象字面量，这样构造出的对象，其[[prototype]]指向Object.prototype
2.这个对象是由构造函数构造出来的。
function person(){} var person1=new person();
通过new操作符调用的函数就是构造函数。由构造函数构造的对象，其[[prototype]]指向其构造函数的prototype属性指向的对象。每个函数都有一个prototype属性，其指向的对象带有constructor属性，这一属性指向函数本身，（在本例中，person1的[[prototype]]指向Person.prototype）
3.这个对象是由函数Object.create构造的。
var person1={ name:'shaw', age:'30' }; var person2=Object.create(person1);
本例中，对象person2的[[prototype]]指向对象person1.在没有Object.create函数的日子里，人们是这样做的：
Object.create=function(p){ function f(){} f.prototype=p; return new f(); }
然而虽然说[[prototype]]是一个隐藏属性，但很多浏览器都给每一个对象提供.__proto__这一属性，这个属性就是上文反复提到的该对象的[[prototype]]。由于这个属性不标准，因此一般不提倡使用。ES5中用Object.getPrototypeOf函数获得一个对象的[[prototype]]。ES6中，使用Object.setPrototypeOf可以直接修改一个对象的[[prototype]]
__proto__ === .constructor.prototype是不对的，如果一个对象是通过Object.create函数构造出来的，.那其__proto__就不一定是.constructor.prototype了