繼承是物件導向程式設計的核心概念之一。由於 JavaScript 並非傳統意義上的類別導向語言,而是採用「以物件為中心」的設計,因此它沒有像 Java 那樣內建的 class 機制。想要在 JavaScript 中實現繼承,我們必須善用它獨有的原型(prototype)特性,或借助 call、apply 等方法來達成。本文將系統性地梳理 JavaScript 中常見的幾種繼承模式,並比較各自的優缺點。
在日常開發中,最常提到的兩大類繼承方式是:
· 原型鏈繼承:著眼於物件與物件之間的委派關係
· 類式繼承:著眼於建構函式與建構函式之間的關係
在傳統物件導向語言裡,我們用 class 來建立自訂物件;但在 JavaScript 中,萬物皆物件,那麼自訂物件該怎麼誕生?答案就是原型。
你可以把 prototype 想像成一個模板,新建立的物件並非真正「複製」了模板,而是透過一條隱形的鏈結指向它。每個被實例化的物件內部都有一個看不見的 __proto__ 指標,指向其原型物件。正是這條鏈結,構成了 JavaScript 模擬類別與實現繼承的基礎。
所謂類式繼承,就是在子類型的建構函式內部呼叫超類型的建構函式。嚴格的類式繼承其實並不常見,實務上多半會與其他模式搭配使用:
function Super(){
this.colors = ["red", "blue"];
}
function Sub(){
Super.call(this);
}
要讓子類繼承父類的屬性與方法,第一步是定義一個建構函式,接著把父類的新實例指派給該建構函式的原型,於是就形成了一條原型鏈:
<script>
function Parent(){
this.name = 'mike';
}
function Child(){
this.age = 12;
}
Child.prototype = new Parent(); // Child 繼承 Parent,透過原型形成鏈條
var test = new Child();
alert(test.age);
alert(test.name); // 得到被繼承的屬性 mike
// 繼續沿著原型鏈繼承
function Brother(){ // Brother 建構函式
this.weight = 60;
}
Brother.prototype = new Child(); // 繼續原型鏈繼承
var brother = new Brother();
alert(brother.name); // 同時繼承了 Parent 與 Child,彈出 mike
alert(brother.age); // 彈出 12
</script>
值得注意的是,原型鏈的頂端其實還有 Object——所有建構函式最終都繼承自 Object。不過這一步是自動完成的,無需我們手動處理。
我們可以透過兩種方式來確認原型與實例之間的關聯:運算子 instanceof 與 isPrototypeOf() 方法。
alert(brother instanceof Object); // true alert(test instanceof Brother); // false,test 是 brother 的超類 alert(brother instanceof Child); // true alert(brother instanceof Parent); // true
只要某個原型曾出現在原型鏈上,它就算是該鏈所派生實例的原型,因此 isPrototypeOf() 也會回傳 true。
在 JavaScript 術語中,被繼承的函式稱為超類型(父類/基類),進行繼承的函式則稱為子類型(子類/派生類)。單純的原型鏈繼承存在兩個明顯問題:一是以字面量重寫原型會中斷原本的關聯;二是使用引用類型的原型時,子類型無法向超類型傳遞參數。
為了解決「引用共享」與「超類型無法傳參」的問題,我們可以採用「借用建構函式」的技巧:
<script>
function Parent(age){
this.name = ['mike', 'jack', 'smith'];
this.age = age;
}
function Child(age){
Parent.call(this, age);
}
var test = new Child(21);
alert(test.age); // 21
alert(test.name); // mike,jack,smith
test.name.push('bill');
alert(test.name); // mike,jack,smith,bill
</script>
借用建構函式雖然解決了上述兩個問題,卻也失去了原型——方法無法復用。因此我們需要把「原型鏈」與「借用建構函式」結合起來,這正是組合繼承的靈感來源。
<script>
function Parent(age){
this.name = ['mike', 'jack', 'smith'];
this.age = age;
}
Parent.prototype.run = function () {
return this.name + ' are both ' + this.age;
};
function Child(age){
Parent.call(this, age); // 物件冒充,向超類型傳參
}
Child.prototype = new Parent(); // 原型鏈繼承
var test = new Child(21); // 寫成 new Parent(21) 亦可
alert(test.run()); // mike,jack,smith are both 21
</script>
組合繼承是最常用的繼承模式,其核心思路是:用原型鏈完成對原型屬性與方法的繼承,再用借用建構函式完成對每個實例自有屬性的繼承。如此一來,既能透過在原型上定義方法來實現函式復用,又能保證每個實例都擁有獨立的屬性。
補充一下 call() 的用法:它用來呼叫某個物件的方法,並以另一個物件取代當前的 this 指向。
call([thisObj[, arg1[, arg2[, ...argN]]]])
這種方式借助原型,並以「已有的物件」為基礎建立新物件,同時不必建立自訂類型:
<script>
function obj(o){
function F(){}
F.prototype = o;
return new F();
}
var box = {
name : 'trigkit4',
arr : ['brother', 'sister', 'baba']
};
var b1 = obj(box);
alert(b1.name); // trigkit4
b1.name = 'mike';
alert(b1.name); // mike
alert(b1.arr); // brother,sister,baba
b1.arr.push('parents');
alert(b1.arr); // brother,sister,baba,parents
var b2 = obj(box);
alert(b2.name); // trigkit4
alert(b2.arr); // brother,sister,baba,parents
</script>
它的運作原理是:先在 obj() 函式內部建立一個臨時建構函式,將傳入的物件設為這個建構函式的原型,最後回傳該臨時類型的新實例。需要注意的是,引用類型的屬性會在多個實例間共享。
寄生式繼承可視為「原型式繼承 + 工廠模式」的組合,目的是封裝物件的建立過程:
<script>
function create(o){
var f = obj(o);
f.run = function () {
return this.arr; // 同樣會共享引用
};
return f;
}
</script>
組合繼承雖然是 JavaScript 中最主流的繼承模式,卻存在一個小小的缺點:超類型的建構函式會被呼叫兩次——一次是在建立子類型時,另一次則是在子類型建構函式內部。
<script>
function Parent(name){
this.name = name;
this.arr = ['哥哥', '妹妹', '父母'];
}
Parent.prototype.run = function () {
return this.name;
};
function Child(name, age){
Parent.call(this, age); // 第二次呼叫
this.age = age;
}
Child.prototype = new Parent(); // 第一次呼叫
</script>
為了解決重複呼叫的問題,我們可以使用寄生組合式繼承:
<script>
function obj(o){
function F(){}
F.prototype = o;
return new F();
}
function create(parent, test){
var f = obj(parent.prototype); // 建立物件
f.constructor = test; // 增強物件
}
function Parent(name){
this.name = name;
this.arr = ['brother', 'sister', 'parents'];
}
Parent.prototype.run = function () {
return this.name;
};
function Child(name, age){
Parent.call(this, name);
this.age = age;
}
inheritPrototype(Parent, Child); // 透過這裡實現繼承
var test = new Child('trigkit4', 21);
test.arr.push('nephew');
alert(test.arr); // 引用問題已解決
alert(test.run()); // 只共享了方法
var test2 = new Child('jack', 22);
alert(test2.arr); // 各實例互不影響
</script>
全域函式 apply 與 call 都能用來改變函式中 this 的指向,範例如下:
// 定義一個全域函式
function foo() {
console.log(this.fruit);
}
// 定義一個全域變數
var fruit = "apple";
// 自訂一個物件
var pack = {
fruit: "orange"
};
// 等同於 window.foo();
foo.apply(window); // "apple",此時 this 等於 window
// 此時 foo 中的 this === pack
foo.apply(pack); // "orange"
掌握這些繼承模式後,你就能依據實際場景選擇最合適的方案。若追求簡單直觀,組合繼承綽綽有餘;若在意效能與細節,寄生組合式繼承則是更理想的選擇。