組合繼承

組合繼承，指將原型鏈和借用建構函式的技術組合到一塊，從而發揮二者之長的一種繼承模式。其背後思路使用用原型鏈實現對原型屬性和方法的繼承，而通過建構函式來實現對例項屬性的繼承。這樣，即通過在原型上定義方法實現了函式複用，又能夠保證每個例項都有它自己的屬性。

下面來看一個例子

function SuperType(name) {
  this.name = name;
  this.color = ['red','blue','green'];
};
//
SuperType.prototype.sayName = function() {
  console.log(this.name);
};
//
function SubType(name,age) {
  //繼承屬性
  SuperType.call(this,name);		// 第二次呼叫SuperType
//
  this.age = age;
};
//繼承方法
SubType.prototype = new SuperType();	// 第一次呼叫SuperType
console.log(SubType.prototype.constructor); //輸出SuperType函式的原始碼,即此時SubType.prototype.constructor指向SuperType函式
SubType.prototype.constructor = SubType; //將SubType.prototype.constructor指標指回SubType函式
SubType.prototype.sayAge = function() {
  console.log(this.age);
};
//
var instance1 = new SubType('Jake',20)
instance1.color.push('black');
console.log(instance1.color); //'red,blue,green,black'
instance1.sayName(); //'Jake'
instance1.sayAge(); //20
//
var instance2 = new SubType('Greg',21);
console.log(instance2.color); //'red,green'
instance2.sayName(); //'Greg';
instance2.sayAge(); //21

觀察輸出結果，便可以發現：兩個SubType例項（instance1和instance2）既分別有自己的屬性，又可以使用相同的方法。

優點

組合繼承避免了原型鏈和借用建構函式的缺陷，融合了它們的優點，所以是JS中最常用的繼承模式。而且，instanceof和isPrototypeOf()也能夠用於識別基於組合繼承建立的物件。

缺點

呼叫兩次SuperType建構函式

在SubType.prototype上建立了不必要的屬性

寄生組合繼承

function SuperType (name) {
 this.name = name
 this.colors = ['red','yellow']
}

SuperType.prototype.sayName = function () {
 console.log(this.name)
}

function SubType (name,age) {
 SuperType.call(this,name) // 通過建構函式繼承例項屬性
 this.age = age
}

SubType.prototype = Object.create(SuperType.prototype)	//繼承父類共享方法
SubType.prototype.constructor = SubType	//將SubType.prototype.constructor指標指回SubType函式
SubType.prototype.sayAge = function () {
 console.log(this.age)
}

let obj = new SubType('jake',22)
obj.sayName()	// jake
obj.sayAge()	// 22
console.log(obj instanceof SubType)	// true
console.log(obj instanceof SuperType)	// true

優點

寄生組合繼承只調用了一次SuperType，所以更高效

避免了在SubType.prototype上建立了不必要的屬性

下面說說原型鏈和建構函式的缺點

原型鏈

缺點：當原型鏈中包含引用型別值時，原型屬性會被所有例項共享；

下面看一個例子

function SuperType() {
  this.color = ['red','green'];
}
//
function SubType() {};
//
SubType.prototype = new SuperType(); //繼承了SuperType
//
var instance1 = new SubType();
instance1.color.push('black');
console.log(instance1.color);  //'red,black'
//
var instance2 = new SubType();
console.log(instance2.color);  //'red,black'

借用建構函式

缺點：如果僅僅使用建構函式，方法都在建構函式中定義，因此函式就無法實現複用了。而且，在超型別的原型中定義的方法，對於子型別而言也是不可見的。

以上就是本文的全部內容，希望對大家的學習有所幫助，也希望大家多多支援我們。