淺談js中的繼承

繼承有兩種方式：接口繼承和實現繼承。接口繼承只繼承方法簽名，而實現繼承則繼承實際的方法。

因爲函數沒有簽名，在ECMAScript中沒法實現接口繼承。ECMAScript只支持實現繼承，並且實現繼承主要依靠原型鏈來實現。

下面介紹幾種js的繼承：

原型鏈繼承

原型鏈繼承實現的本質是重寫原型對象，代之以一個新類型的實例。代碼以下：

function SuperType() {
    this.property = true;
}

SuperType.prototype.getSuperValue = function() {
    return this.property;
};

function SubType() {
    this.subproperty = false;
}

// 繼承了SuperType
SubType.prototype = new SuperType();

SubType.prototype.getSubValue = function () {
    return this.subproperty;
};

var instance = new SubType();

console.log(instance.getSuperValue());  // true

能夠看到instance調用了父級的getSuperVlue()方法，實現了繼承。

原型鏈的繼承有以下問題：

1. 包含引用類型值的原型時，在改變原型的引用類型時，會所有改了
2. 在建立子類型的實例時，沒有辦法在不影響全部對象實例的狀況下，給超類型的構造函數傳遞參數

示例代碼以下：

function SuperType1() {
    this.colors = ['red', 'blue', 'green'];
}
function SubType1() {

}
SubType1.prototype = new SuperType1();
var instance1 = new SubType1();
instance1.colors.push('black');
console.log(instance1.colors);  // [ 'red', 'blue', 'green', 'black' ]

var instance2 = new SubType1();
console.log(instance2.colors);  // [ 'red', 'blue', 'green', 'black' ]

能夠發現，instance1和instance2的colors屬性是共享的，這就出問題了，同時也可以看出，在new一個新的方法時，若是傳值的話，是傳不到父級的。

借用構造函數

原理是在子類型構造函數的內部調用超類型構造函數，由於函數只不過是在特定環境中執行代碼的對象，這樣就能夠獲取父級的方法和屬性了。

代碼以下：

function SuperType(name) {
    this.name = name;
}

function SubType(name) {
    // 繼承了SuperType，同時還傳遞了參數
    SuperType.call(this, name);

    // 實例屬性
    this.age = 29;
}

var instance = new SubType('Bob');

console.log(instance.name);  // Bob
console.log(instance.age);  // 29

能夠看出，調用構造函數繼承解決了向父類型傳參的問題，但調用構造函數也有其自身的問題：

1. 方法都在構造函數中，函數複用沒有了。
2. 超類型的原型中定義的方法，對子類型而言是不可見的。

第一個問題很明顯，針對第二個問題的解釋是，因爲只是執行了一次函數，並無new出新對象，故而父類prototype中的方法對子類是不可見的。

組合繼承

因爲原型鏈繼承和借用構造函數繼承都有缺陷，故而在實際中通常不會單獨使用。

組合繼承是借用其二者的優勢而產生的繼承方法。

其原理是使用原型鏈實現對原型屬性和方法的繼承，經過借用構造函數來實現對實例屬性的繼承。

代碼以下：

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

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.constructor = SubType;
SubType.prototype.sayAge = function() {
    console.log(this.age);
};

var instance1 = new SubType('Nicholas', 29);
instance1.colors.push('black');

console.log(instance1.colors);  // [ 'red', 'blue', 'green', 'black' ]
instance1.sayName();  // Nicholas
instance1.sayAge(); // 29

var instance2 = new SubType('Greg', 27);

console.log(instance2.colors);  // [ 'red', 'blue', 'green' ]
instance2.sayName();  // Greg
instance2.sayAge();  // 27

組合繼承可以解決上面兩種繼承方式帶來的問題，可是組合繼承也有其自身的小問題，那就是會調用兩次超類型構造函數，經過分析即可知道 一次是在建立子類型原型的時候，另外一次是在子類型構造函數內部。

寄生組合式繼承

寄生組合式繼承的原理爲經過借用構造函數來繼承屬性，經過原型鏈的混成形式來繼承方法，基本思路是沒必要爲了指定子類型的原型而調用超類型的構造函數，咱們所須要的無非就是超類型原型的一個副本而已。

代碼以下：

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

function inheritPrototype(subType, superType) {
    var prototype = object(superType.prototype);
    prototype.constructor = subType;
    subType.prototype = prototype;
}

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

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 instance = new SubType('天涯', 23);
instance.sayName();
instance.sayAge();

寄生組合式繼承只有在調用構造函數時執行了一遍超類型，解決了組合繼承的小問題。

後記

js的繼承不分好壞，應針對不一樣的需求和場景來選擇不一樣的繼承方法。

歡迎你們來指正~