DIV CSS 佈局教程網

深入理解原型鏈與 JavaScript 的繼承機制
編輯:關於JavaScript     

上一篇文章談了原型的概念,釐清了 constructor、prototype 與 instance 三者之間的三角關係:每個建構函數都有一位「守護神」原型物件,原型物件的 constructor 屬性又回頭指向建構函數,而每一個實例則透過內部連結指向原型物件。

JavaScript 並非物件導向語言,而是「基於物件」的語言。對習慣其他 OO 語言的人來說,起初會很不適應:這裡沒有「類」的概念,或者說類與實例並不區分,更不要說父類與子類。那這一堆物件該怎麼串起來?幸運的是,JavaScript 從設計之初就提供了繼承的實作方式。

原型鏈是怎麼形成的

原型物件都有一個指向建構函數的指標。如果我們讓 SubClass 的原型物件等於另一個型別的實例 new SuperClass(),那麼 SubClass 的原型物件裡就多了一個指向 SuperClass 原型的指標,而 SuperClass 原型裡又有指向 SuperClass 建構函數的指標……層層遞進下去,就形成了一條原型鏈。

function SuperClass(){
  this.name = "women";
}
SuperClass.prototype.sayWhat = function(){
  return this.name + ":i`m a girl!";
};

function SubClass(){
  this.subname = "your sister";
}
SubClass.prototype = new SuperClass();
SubClass.prototype.subSayWhat = function(){
  return this.subname + ":i`m a beautiful girl";
};

var sub = new SubClass();
console.log(sub.sayWhat()); // women:i`m a girl!

SubClass 繼承了 SuperClass 的屬性與方法,關鍵就在那一行「把 SuperClass 的實例指派給 SubClass 的原型」。這麼做之後,SubClass 原本的原型物件被整個覆蓋,換成一個 SuperClass 的實例,於是既擁有了它的全部屬性與方法,也保留了指向 SuperClass 原型的指標。

使用原型鏈時的三個陷阱

一、constructor 指向改變了。此時 sub.constructor 指向的是 SuperClass,因為 SubClass 的原型已被換成 SuperClass 的實例。實務上若有用到 constructor,必須手動補回:

SubClass.prototype.constructor = SubClass;

另外別忘了原型鏈的末端還有預設的 Object 物件,這也是為什麼任何物件都能呼叫 toString 這類內建方法——它其實是沿著原型鏈找到 Object.prototype 上的實作。

二、不能用字面量重新定義原型方法。一旦寫成 SubClass.prototype = { ... },就等於又把原型換掉一次,先前建立的繼承連結全部作廢:

function SuperClass(){
  this.name = "women";
}
SuperClass.prototype.sayWhat = function(){
  return this.name + ":i`m a girl!";
};

function SubClass(){
  this.subname = "your sister";
}
SubClass.prototype = new SuperClass();
SubClass.prototype = {   // 原型又被覆蓋,繼承連結斷了
  subSayWhat: function(){
    return this.subname + ":i`m a beautiful girl";
  }
};

var sub = new SubClass();
console.log(sub.sayWhat()); // TypeError: undefined is not a function

三、引用型別屬性會被所有實例共享。這是最嚴重的問題。原型上的陣列或物件會被所有實例共用,任何一個實例改動它,其他實例都會受影響:

function SuperClass(){
  this.name = "women";
  this.bra = ["a", "b"];
}
function SubClass(){
  this.subname = "your sister";
}
SubClass.prototype = new SuperClass();

var sub1 = new SubClass();
sub1.name = "man";
sub1.bra.push("c");
console.log(sub1.name);  // man
console.log(sub1.bra);   // ["a","b","c"]

var sub2 = new SubClass();
console.log(sub2.name);  // women —— 不受影響
console.log(sub2.bra);   // ["a","b","c"] —— 被汙染了

注意這個對比:修改 name 不影響其他實例,因為它是基本型別,賦值會在實例上建立同名屬性遮蔽原型;而 bra 是陣列,push 是直接改動原型上那個共用物件,於是全部實例一起受牽連。這不僅浪費資源,也不是我們想要的行為。

經典繼承:借用建構函數

為了解決引用共用的問題,出現了「借用建構函數」的做法——在子類型建構函數中呼叫超類型建構函數,藉助 call 或 apply 改變作用域:

function SuperClass() {
  this.name = "women";
  this.bra = ["a", "b"];
}
function SubClass() {
  this.subname = "your sister";
  SuperClass.call(this);   // 把 SuperClass 的作用域套到當前實例上
}

var sub1 = new SubClass();
sub1.bra.push("c");
console.log(sub1.bra);     // ["a","b","c"]

var sub2 = new SubClass();
console.log(sub2.bra);     // ["a","b"] —— 各自獨立

這一行 SuperClass.call(this) 的意思是:在 SubClass 實例的環境中執行一次 SuperClass 的初始化。於是每個實例都有一份自己的 bra 副本,互不干擾。

但它並不完美。既然屬性可以靠建構函數搞定,方法卻不行——若把方法定義在建構函數裡,每個實例都會有一份獨立的函數參考,而我們本意是想共用;更麻煩的是,定義在超類型原型上的方法,子類型實例完全呼叫不到:

function SuperClass() {
  this.name = "women";
  this.bra = ["a", "b"];
}
SuperClass.prototype.sayWhat = function(){ console.log("hello"); }

function SubClass() {
  this.subname = "your sister";
  SuperClass.call(this);
}
var sub1 = new SubClass();
console.log(sub1.sayWhat()); // TypeError: undefined is not a function

因為 SubClass 的原型鏈上完全沒有 SuperClass.prototype。答案呼之欲出:兩者合用。

組合式繼承

組合繼承結合了原型鏈與借用建構函數的優勢:用原型鏈繼承原型上的屬性與方法,用借用建構函數繼承實例自己的屬性:

function SuperClass() {
  this.name = "women";
  this.bra = ["a", "b"];
}
SuperClass.prototype.sayWhat = function(){ console.log("hello"); }

function SubClass() {
  this.subname = "your sister";
  SuperClass.call(this);        // 第二次呼叫 SuperClass
}
SubClass.prototype = new SuperClass();  // 第一次呼叫 SuperClass

var sub1 = new SubClass();
console.log(sub1.sayWhat());    // hello

這也是實務上最常使用的繼承方式,到此已能滿足絕大多數需求。但追求完美的人立刻會挑刺:你呼叫了兩次超類型的建構函數!放大一百倍,這是多大的效能浪費?

寄生組合式繼承:目前最理想的方案

先看「寄生式建構函數」的概念。它類似工廠模式,定義一個函數專門負責建立物件並回傳,差別只在函數名稱大寫、慣例上用 new 呼叫:

function Gf(name, bra){
  var obj = new Object();
  obj.name = name;
  obj.bra = bra;
  obj.sayWhat = function(){ console.log(this.name); };
  return obj;
}
var gf1 = new Gf("bingbing", "c++");
console.log(gf1.sayWhat()); // bingbing

而「原型式繼承」則是道格拉斯(Douglas Crockford)提出的一種精簡做法——用一個空建構函數暫存傳入物件,回傳它的實例:

function object(obj) {
  function F() {}
  F.prototype = obj;
  return new F();
}
var superClass = { name: "bingbing", bra: "c++" };
var subClass = object(superClass);
console.log(subClass.name); // bingbing

這個函數建立了 F 並把傳入物件設為其原型,最後回傳 F 的實例,簡單但有效。在它之上「增強物件、加上自訂屬性」,就是寄生式繼承:

function buildObj(obj){
  var o = object(obj);
  o.sayWhat = function(){ console.log("hello"); };
  return o;
}
var superClass = { name: "bingbing", bra: "c++" };
var gf = buildObj(superClass);
gf.sayWhat(); // hello

寄生式繼承同樣有函數無法重複使用的問題。於是出現了寄生組合式繼承:不呼叫超類型建構函數來建立原型,而是直接複製超類型的原型,如此既避免重複呼叫,又保住原型鏈:

// 參數為兩個建構函數
function inheritObj(sub, sup){
  var proto = object(sup.prototype); // 取得超類型原型的一份副本
  proto.constructor = sub;           // 修正 constructor 指向
  sub.prototype = proto;             // 指派給子類型原型
}

function SuperClass() {
  this.name = "women";
  this.bra = ["a", "b"];
}
SuperClass.prototype.sayWhat = function() { console.log("hello"); }

function SubClass() {
  this.subname = "your sister";
  SuperClass.call(this);     // 唯一一次的建構函數呼叫,只處理實例屬性
}
inheritObj(SubClass, SuperClass);

var sub1 = new SubClass();
console.log(sub1.sayWhat()); // hello

這個寫法有三重好處:超類型建構函數只被呼叫一次;不必為了解繼承而在 SubClass.prototype 上留一個用不到的 SuperClass 實例屬性;原型鏈完整保留,constructor 也正確。因此被視為目前最理想的繼承實作。

結語

關於 JavaScript 該不該硬做 OO,爭論至今仍在:有人主張引入類別語法,有人認為在這語言上模擬 OO 是徒勞。但若把時間軸拉到今天,ES6 的 class 與 extends 其實就是這套機制的語法糖——extends 編譯後的行為,本質上等同於寄生組合式繼承;而 super 關鍵字則封裝了 SuperClass.call(this) 這件事。理解底層怎麼運作,才能在遇到 this 指向、原型污染或 instanceof 判定失敗這類問題時,知道該往哪裡查。

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