1.prototype 属性的作用
JavaScript 继承机制的设计思想就是，原型对象的所有属性和方法，都能被实例对象共享。如果属性和方法定义在原型上，那么所有实例对象就能共享，不仅节省了内存，还体现了实例对象之间的联系。
只要创建了一个新函数，就会根据一组特定的规则为该函数创建一个prototype属性，默认情况下prototype属性会默认获得一个constructor(构造函数)属性，
function f() {}
console.log(typeof f.prototype); // "object"
上面代码中，函数f默认具有prototype属性，指向一个对象。
function Person(name) {
this.name = name;
}
Person.prototype.color = 'yellow';
let Asia1 = new Person('张三');
let Asia2 = new Person('王二');
console.log(Asia1.color); // 'yellow'
console.log(Asia2.color); // 'yellow'
Asia1.color="white";
console.log(Asia1.color); // 'white'
console.log(Asia2.color); // 'yellow'
Person.prototype.walk = function () {
console.log(this.name +' is '+this.color + ' and now is walking');
};
Asia1.walk();//张三 is white and now is walking
Asia2.walk();//王二 is yellow and now is walking
上面代码中，构造函数Person的prototype属性，就是实例对象Asia1和Asia2的原型对象。原型对象上添加一个color属性和一个walk方法，结果，实例对象都共享了该属性和方法。我们使用Asia1.color="white"为Asia1添加color，发现Asia1.color获取自身属性值为white,而Asia2.color的值还是获取的原型对象上的值。
总结一下：
当实例对象本身没有某个属性或方法的时候，它会到原型对象去寻找该属性或方法。这就是原型对象的特殊之处。
当实例对象自身就有某个属性或方法，它就不会再去原型对象寻找这个属性或方法。
原型对象的作用，就是定义所有实例对象共享的属性和方法。这也是它被称为原型对象的原因，而实例对象可以视作从原型对象衍生出来的子对象。
2.原型链
JavaScript 规定，所有对象都有自己的原型对象（prototype）。一方面，任何一个对象，都可以充当其他对象的原型；另一方面，由于原型对象也是对象，所以它也有自己的原型。因此，就会形成一个“原型链”（prototype chain）：对象到原型，再到原型的原型，如此链式下去。
怎么获取实例对象的原型呢？
可以使用Object.getPrototypeOf()方法，也可以使用实例对象的__proto__属性（前后各两个下划线）。
可参考我的这篇随笔：JavaScript Object 对象的相关方法
所有对象的原型最终都可以上溯到Object.prototype，即Object构造函数的prototype属性。这就是所有对象都有valueOf和toString方法的原因，因为这是从Object.prototype继承的。
那思考一下，Object.prototype没有它的原型呢？
console.log(Object.getPrototypeOf(Object.prototype));//null
上面代码表示，Object.prototype对象的原型是null，由于null没有任何属性，所以原型链到此为止。Object.getPrototypeOf方法返回参数对象的原型。
读取对象的某个属性时，JavaScript 引擎先寻找对象本身的属性，如果找不到，就到它的原型去找，如果还是找不到，就到原型的原型去找，一直到最顶层的Object.prototype。（注意：越上层查找，对性能的影响越大）如果对象自身和它的原型有同名的属性，那么优先读取对象自身的属性，这叫做“覆盖”（overriding）。
3.constructor 属性
prototype对象有一个constructor属性，默认指向prototype对象所在的构造函数。
function Fnc() {
}
console.log( Fnc.prototype.constructor ===Fnc);//true
由于constructor属性定义在prototype对象上面，意味着可以被所有实例对象继承。
function Func() {
}
let myFunc = new Func();
console.log(myFunc.constructor === Func);//true
console.log(myFunc.constructor === Func.prototype.constructor);//true
console.log(myFunc.hasOwnProperty('constructor'));//false
上面代码中，myFunc是构造函数Func的实例对象，但是myFunc实例自身没有constructor属性，该属性其实是读取原型链上面的Func.prototype.constructor属性。
因此，可以得出，constructor属性的作用是：得知某个实例对象，到底是哪一个构造函数产生的。
//接上例
console.log(myFunc.constructor === Array);//false
上面代码中，constructor属性确定了实例对象myFunc的构造函数是Func，而不是Array。
//接上例
let newFunc = new myFunc.constructor();
console.log(newFunc.constructor==Func);//true
上面代码中，myFunc是构造函数Func的实例，可以从myFunc.constructor间接调用构造函数。这使得在实例方法中，调用自身的构造函数成为可能。
constructor属性表示原型对象与构造函数之间的关联关系，如果修改了原型对象，一般会同时修改constructor属性，防止引用的时候出错。
//接上例
console.log(Func.prototype.constructor === Func);//true
//修改Func的原型对象
Func.prototype = {
newProtype: function () {
}
}
console.log(Func.prototype.constructor === Func);//false
console.log(Func.prototype.constructor === Object);//true
上面代码中，构造函数Func的原型对象改掉了，但是没有修改constructor属性，导致这个属性不再指向Person。由于Func的新原型是一个普通对象，而普通对象的constructor属性指向Object构造函数，导致Func.prototype.constructor变成了Object。
所以，修改原型对象时，一般要同时修改constructor属性的指向。
//接上例
Func.prototype = {
constructor:Func,
newProtype: function () {
}
}
//最好的写法
//Func.prototype.newProtype= function(){};
console.log(Func.prototype.constructor === Func);//true
console.log(Func.prototype.constructor === Object);//false
上面代码中，要么将constructor属性重新指向原来的构造函数，要么只在原型对象上添加方法，这样可以保证指向一致。
如果不能确定constructor属性是什么函数，还有一个办法：通过name属性，从实例得到构造函数的名称。
//接上例
console.log(myFunc.constructor.name);//Func
4.instanceof 运算符
instanceof运算符返回一个布尔值，表示对象是否为某个构造函数的实例。
function Func() {
}
let v = new Func();
console.log(v instanceof Func); // true
// 等同于
console.log(Func.prototype.isPrototypeOf(mFunc));//true
instanceof运算符的左边是实例对象，右边是构造函数。它会检查右边构建函数的原型对象（prototype），是否在左边对象的原型链上。上面代码两种方式是等价的。
由于instanceof检查整个原型链，因此同一个实例对象，可能会对多个构造函数都返回true。
console.log(mFunc instanceof Object); // true
instanceof的原理是检查右边构造函数的prototype属性，是否在左边对象的原型链上。有一种特殊情况，就是左边对象的原型链上，只有null对象。这时，instanceof判断会失真。
let obj = Object.create(null);
console.log(typeof obj); // "object"
console.log(obj instanceof Object); // false
上面代码中，Object.create(null)返回一个新对象obj，它的原型是null（Object.create的详细介绍见后文）。右边的构造函数Object的prototype属性，不在左边的原型链上，因此instanceof就认为obj不是Object的实例。但是，只要一个对象的原型不是null，instanceof 运算符的判断就不会失真。
注意，instanceof运算符只能用于对象，不适用原始类型的值。
5.构造函数的继承
让一个构造函数继承另一个构造函数，是非常常见的需求。这可以分成两步实现。第一步是在子类的构造函数中，调用父类的构造函数。
function Sub(value) {
Super.call(this);
this.prop = value;
};
Sub.prototype = Object.create(Super.prototype);
Sub.prototype.constructor = Sub;
Sub.prototype.method = '...';
上面代码中，Sub是子类的构造函数，Super是父类的构造函数,this是子类的实例。
第一步是在子类的构造函数中，调用父类的构造函数。在实例上调用父类的构造函数Super，就会让子类实例具有父类实例的属性。
第二步，是让子类的原型指向父类的原型，这样子类就可以继承父类原型。Sub.prototype是子类的原型，要将它赋值为Object.create(Super.prototype)，而不是直接等于Super.prototype。否则后面两行对Sub.prototype的操作，会连父类的原型Super.prototype一起修改掉。
举例来说：
function Shape() {
this.x = 10;
this.y = 10;
}
Shape.prototype.move = function (x, y) {
this.x += x;
this.y += y;
console.info('Shape moved.','x='+this.x+',y='+this.y);//Shape moved. x=11,y=12
};
// 第一步，子类继承父类的实例
function Rectangle() {
Shape.call(this); // 调用父类构造函数
}
// 第二步，子类继承父类的原型
Rectangle.prototype = Object.create(Shape.prototype);
Rectangle.prototype.constructor = Rectangle;
let rect = new Rectangle();
rect.move(1,2);
console.log(rect instanceof Rectangle); // true
console.log(rect instanceof Shape); // true
6.多重继承
JavaScript 不提供多重继承功能，即不允许一个对象同时继承多个对象。但是，可以通过变通方法，实现这个功能。
function Func1() {
this.hello = 'hello';
}
function Func2() {
this.world = 'world';
}
function S() {
Func1.call(this);
Func2.call(this);
}
// 继承 Func1
S.prototype = Object.create(Func1.prototype);
// 继承链上加入 Func1
Object.assign(S.prototype, Func2.prototype);
// 指定构造函数
S.prototype.constructor = S;
let s = new S();
console.log(s.hello); // 'hello'
console.log(s.world); // 'world'
上面代码中，子类S同时继承了父类Func1和Func2。这种模式又称为 Mixin（混入）。