DIV CSS 佈局教程網

深入 JavaScript 繼承:從原型鏈到組合繼承的完整指南
編輯:JavaScript綜合知識     

繼承是物件導向程式設計的核心概念之一。由於 JavaScript 並非傳統意義上的類別導向語言,而是採用「以物件為中心」的設計,因此它沒有像 Java 那樣內建的 class 機制。想要在 JavaScript 中實現繼承,我們必須善用它獨有的原型(prototype)特性,或借助 call、apply 等方法來達成。本文將系統性地梳理 JavaScript 中常見的幾種繼承模式,並比較各自的優缺點。

一、什麼是 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>

十、call 與 apply 的應用

全域函式 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"

掌握這些繼承模式後,你就能依據實際場景選擇最合適的方案。若追求簡單直觀,組合繼承綽綽有餘;若在意效能與細節,寄生組合式繼承則是更理想的選擇。

XML學習教程| jQuery入門知識| AJAX入門| Dreamweaver教程| Fireworks入門知識| SEO技巧| SEO優化集錦|
Copyright © DIV+CSS佈局教程網 All Rights Reserved