JavaScript 是物件導向語言,但它的繼承機制從設計之初就與傳統的類別式語言不同——它採用的是基於原型的繼承。在這個機制之上,社群發展出幾種不同的實作方式,各有取捨。本文逐一拆解。
所謂類式繼承,就是模仿傳統物件導向語言的繼承形式,讓繼承的雙方都呈現「類」的樣貌。
先定義父類:
function Person(name) {
this.name = name; // 寫在建構器裡:每個實例各自獨立
}
Person.prototype.getName = function () {
return this.name;
};
這個設計有兩個刻意的選擇。屬性寫在建構器中,可以保證繼承它的子類擁有獨立的 name,不與父類共用;方法掛在 prototype 上,則是為了讓所有實例共用同一份函數——每次 new 出來的實例,其 getName 都參照同一段記憶體空間,而不是各自複製一份。
再定義繼承函式:
function extend(subClass, superClass) {
var F = function () {};
F.prototype = superClass.prototype; // F 的原型指向父類原型
subClass.prototype = new F(); // 子類原型指向 F 的實例
subClass.prototype.constructor = subClass;
subClass.superClass = superClass.prototype;
if (superClass.prototype.constructor == Object.prototype.constructor) {
superClass.prototype.constructor = superClass;
}
}
這段程式碼的巧妙之處在於引入一個空的過渡建構器 F。如果直接寫 subClass.prototype = new superClass(),就會呼叫父類建構器,可能產生副作用(例如需要參數卻沒傳)。用空的 F 承接父類原型,就能建立原型鏈而不觸發父類建構器。
另外三行是修補工作:因為 prototype 被整體替換,原本正確的 constructor 指向就丟了,要手動補回子類;superClass 屬性則是給子類一個呼叫父類的通道。
定義子類並繼承:
function Author(name, books) {
Author.superClass.constructor.call(this, name); // 借用父類建構器
this.book = books; // 自己的屬性
}
extend(Author, Person);
Author.prototype.getBooks = function () {
return this.book;
};
子類建構器中透過 superClass.constructor.call(this, name) 呼叫父類建構器,並用 call 把 this 的指向轉換為當前子類實例。這一手法稱為「借用建構器」,讓子類取得父類在該建構器中定義的屬性。extend() 則負責接上原型鏈,繼承父類原型上的方法。最後子類掛上自己的 getBooks,完成擴充。
取捨:優點是對習慣傳統物件導向概念的開發者非常直觀。缺點是過程繁瑣、記憶體消耗稍大——子類有自己的建構器與原型,且父子屬性完全隔離,即使值相同也無法共用記憶體。
用物件字面量定義父類:
var Person = {
name: 'default name',
getName: function () { return this.name; }
};
定義克隆函式:
function clone(obj) {
function F() {}
F.prototype = obj; // 把新物件原型指向父類
return new F();
}
這裡的關鍵是:回傳的物件本身沒有任何自有屬性,所有存取都透過原型鏈委派給父類。
子類透過克隆繼承:
var Author = clone(Person);
Author.book = ['javascript'];
Author.showBook = function () { return this.book; };
此時 Author 透過原型鏈擁有 name 屬性,值與父類相同,因此沒有覆寫。若要給子類不同的值,直接賦值即可:
Author.name = 'new name';
取捨:相比類式繼承,原型式繼承更簡潔自然。若子類的屬性值與父類相同而不需修改,兩者實際上共用同一段記憶體。缺點是對習慣傳統物件導向的開發者較難理解。若要在兩者間選擇,這種方式通常更優秀。
值得注意的是,ES5 已經把這個模式標準化為 Object.create():
var Author = Object.create(Person);
問題在於:JavaScript 中每個物件的原型只能指向單一對象,無法指向多個,那要怎麼實現多重繼承?
《JavaScript 設計模式》一書提出了摻元類(mixin class)的解法。思路是:定義一些可重複使用的類別,把其中的方法與屬性「複製」到其他類別的原型上。若同時摻入多個,該類別就間接實現了多重繼承。
定義摻元類:
var Mixin = function () {};
Mixin.prototype = {
serialize: function () {
var output = [];
for (key in this) {
output.push(key + ":" + this[key]);
}
return output.join(',');
}
};
這個 serialize 方法會遍歷自身屬性,組合成字串回傳。
定義擴充函式:
function augment(receivingClass, givingClass) {
if (arguments[2]) {
// 只拷貝指定的屬性 / 方法
for (var i = 2, len = arguments.length; i < len; i++) {
receivingClass.prototype[arguments[i]] = givingClass.prototype[arguments[i]];
}
} else {
// 拷貝全部(不覆蓋接收方已有的成員)
for (methodName in givingClass.prototype) {
if (!receivingClass.prototype[methodName]) {
receivingClass.prototype[methodName] = givingClass.prototype[methodName];
}
}
}
}
這個函式預設兩個參數:接收擴充的類別,以及提供能力的摻元類。若傳入第三個起的參數,就只拷貝那些指名的方法或屬性;否則拷貝全部。本質上是把摻元類原型上的成員搬到接收類的原型上。
使用擴充達成多重繼承:
augment(Author, Mixin);
var author = new Author('js', ['javascript design patterns']);
alert(author.serialize());
執行結果如下:

可以看到這個物件同時具備了 Person、Author 與 Mixin 三者的屬性與方法。其中 Person 的能力來自原型式繼承,Mixin 的能力來自摻元,從實際效果上講,它實現了多重繼承。若需要更多能力,只要再定義更多摻元類並逐一 augment 即可。
| 方式 | 核心機制 | 優點 | 缺點 |
|---|---|---|---|
| 類式繼承 | 過渡建構器接上原型鏈 + 借用建構器 | 概念直觀,父子屬性獨立 | 程式碼繁瑣,記憶體消耗較大 |
| 原型式繼承 | Object.create 語義,原型委派 | 簡潔自然,可共用記憶體 | 直覺性較差,屬性容易意外共用 |
| 摻元類 | 把成員複製到原型上 | 可組合多個來源,實現多重繼承 | 是複製而非委派,方法衝突需自行處理 |
ES6 的 class 語法本質上是原型繼承的語法糖,底層機制與上述相同,但可讀性大幅提升:
class Person {
constructor(name) {
this.name = name;
}
getName() { return this.name; }
}
class Author extends Person {
constructor(name, books) {
super(name);
this.book = books;
}
getBooks() { return this.book; }
}
如果要組合多個來源的行為,ES2015 之後的做法通常是 Object.assign() 搭配 mixin 函式,或直接改用組合(composition)取代繼承——把能力當成元件注入,而非沿著原型鏈往上找。這是現代 JavaScript 設計思潮的明顯轉向:「優先組合而非繼承」,因為它避免了深層原型鏈帶來的脆弱基類問題。