原型鏈繼承
先說原型鏈繼承的問題：包含引用類型屬性的原型（不想被共享的引用屬性）會變成共享。
function SuperType(name){
this.name = name;
this.type = 'color';
this.colors = ['yellow', 'white'];
}
SuperType.prototype.sayType = function() {
console.log(this.type);
};
SuperType.prototype.sayName = function() {
console.log(this.name);
};
function SubType(name){
this.name = name;
}
SubType.prototype = new SuperType(this.name);
var ins1 = new SubType();
ins1.colors.push('red');
console.log(ins1.colors); //'yellow', 'white', 'red'
var ins2 = new SubType('issac');
console.log(ins2.colors); //'yellow', 'white', 'red'
ins2.sayType();
ins2.sayName();
根據超類，colors應該為每個實例獨有、不共享的，但由上面的代碼可見，由于原型鏈繼承后，colors變成了共享的屬性
造成此結果的原因是：以SuperType的實例作為了prototype，而每個對象實例都只是指向這個prototype，因此每個實例擁有的colors實際都是同一個colors，換言之ins1.colors和ins2.colors存放都是同一個指針。
原型鏈繼承的問題：無法保證“私有”引用類型繼續“私有”
借調構造函數繼承
為解決原型鏈本應為實例獨有的引用屬性變成共享屬性的問題，提出借調構造函數繼承
function SuperType(name){
this.name = name;
this.colors = ['yellow', 'white'];
}
SuperType.prototype.sayName = function(){
console.log(this.name);
}
function SubType(name, age){
SuperType.call(this, name);
this.age = age;
}
var sub = new SubType('issac', 18);
sub.sayName();
借調構造函數解決上面提出了的問題，而且接受參數更加的方便
構造函數自身的老問題：
由于構造函數會將它的把內容創建在一個新的作用域內賦給實例，因此，同樣功能的方法就會為每個實例新建一份。這樣本應共有的方法一旦多起來，創建的對象實例一旦多起來，就會造成很大冗余，這就是方法無法復用的問題。而且你也看到了，假如父類是使用組合式創建對象（組合原型式和構造函數式），子類是無法繼承父類的原型的，因此上面
sub.sayName();才會拋出異常，因為subType中確實沒有這個方法。
組合繼承
由上面兩種繼承的方式可以看出： 原型鏈繼承 不能保證“私有”引用屬性繼續“私有”，但是 借調構造函數 可以；借調構造函數繼承 不可以復用方法，但 原型鏈繼承 可以。那么可以組合兩種方式的長處，使用 原型鏈繼承 繼承共享屬性和方法，使用 借調構造函數 繼承“私有”屬性。
function SuperType(name){
this.name = name;
this.colors = ['yellow', 'white'];
}
SuperType.prototype.sayName = function(){
console.log(this.name);
}
function SubType(name, age){
SuperType.call(this, name);
this.age = age;
}
SubType.prototype = new SuperType();
//公用方法和屬性要定義后將父對象的實例賦值給SubType對象之后，不然會因為重寫prototype而被“抹去”
SubType.prototype.constructor = SuperType;
SubType.prototype.sayAge = function(){
console.log(this.age);
}
var ins1 = new SubType('a', 18);
ins1.colors.push('red');
console.log(ins1.colors); //'yellow', 'white', 'red'
var ins2 = new SubType('b', 18);
console.log(ins2.colors); //'yellow', 'white'
要理解組合繼承是怎么工作的，要先知道一件事：js會先執行prototype的代碼，再執行構造函數的代碼。
首先是執行 SubType.prototype = new SuperType(); 這句相當于給SubType的原型對象創建了
//以下是涉及的主要部分
{
name: undefined,
colors: ['yellow', 'white'],
[[prototype]]: SuperType.prototype //包含了SuperType的公有方法和屬性
}
然后在新建SubType對象實例 var ins1 = new SubType('a', 18);的時候調用構造函數，相當于給ins1對象創建“私有”屬性：
//這里我不太會表達下面屬性是ins1獨有的屬性，姑且如下面這樣寫，但愿不會誤導人
var name = 'a';
var age = 18;
var colors = ['yellow', 'white'];
這些屬性會屏蔽原型對象的同名屬性，從而達到“私有”。
原型式繼承
通過封裝一個函數來作為繼承的媒介
function object(o){
function F(){}
F.prototype = o;
return new F();
}
var person = {
name: "issac",
friends: ['frank', 'Aye'],
};
var anthorPerson = object(person);
anthorPerson.name = 'Annd';
anthorPerson.friends.push('Dda');
在ES5中添加Object.create()方法規范了這種繼承，這個方法接受兩個參數，一個是原型對象，第二個是需要新增的屬性會方法[可選]
var person = {
name: "issac",
friends: ['frank', 'Aye'],
};
var anthorPerson = Object.create(person);
anthorPerson.name = 'Annd';
anthorPerson.friends.push('Dda');
var yetPerson = Object.create(person, {
name: {
value: 'issac'
}
});
Object.create()僅在IE9+支持，特別指出IE其他的瀏覽器就不說了
寄生式繼承
寄生式繼承是和原型式繼承緊密相關的思路。
function object(o){
function F(){}
F.prototype = o;
return new F();
}
function createAnthor(o){
var clone = object(o);
clone.sayHi = function(){
console.log('Hi Issac');
}
}
var person = {
name: "issac",
friends: ['frank', 'Aye'],
};
var anthorPerson = createAnthor(person);
anthorPerson.sayHi(); //Hi Issac
寄生的精髓即在原有對象上進行擴展
寄生組合式繼承
在說組合繼承的時候，已經說過超類是會被調用兩次，“私有”屬性的繼承即通過對象實例的屬性對原型對象的屏蔽，顯然，原型對象中的“私有”屬性是多余了。為解決中多余，提出了 寄生組合式繼承
function object(o){
function F(){}
F.prototype = o;
return new F();
}
function inheritPrototype(subType, superType){
var prototype = object(superType.prototype);
prototype.constructor = superType;
subType.prototype = prototype;
}
function SuperType(name){
this.name = name;
this.colors = ['yellow', 'white'];
console.log(Math.round(Math.random()*10)); //打印一個0~10的隨機數
}
SuperType.prototype.sayName = function(){
console.log(this.name);
}
function SubType(name, age){
SuperType.call(this, name);
this.age = age;
}
//繼承
inheritPrototype(SubType, SuperType);
SubType.prototype.sayAge = function(){
console.log(this.age);
}
var ins1 = new SubType('issac1', 18);
ins1.colors.push('red');
console.log(ins1.colors);
以上代碼的執行結果
**顯然，使用寄生組合式繼承僅僅調用了一次超類。
使用組合繼承，會調用2次超類：
第一次，以超類的實例作為子類的原型對象（原型鏈式繼承）；
第二次，創建子類的對象實例時調用子類構造函數，子類構造函數，通過借調構造函數繼承調用超類的構造函數；
寄生組合式繼承是抹去上面說的第一次調用超類。它是通過直接將超類的原型對象賦值給子類的原型對象，然后子類在此基礎上進行個擴充，這樣就會不會觸發到超類的構造函數。**
