上一篇文章談了原型的概念,釐清了 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 判定失敗這類問題時,知道該往哪裡查。