JavaScript 是面向對象的語言,社群裡那句「萬物皆對象」人人會背。既然是面向對象,就有封裝、繼承、多型這三件事。本文只談繼承——而且談的是 JavaScript 最特殊、也最容易讓人栽跟頭的那部分:它的繼承不基於 class,而基於原型。
寫過 C++ 的人可以把原型粗略類比為「類」,同樣用來保存屬性與方法。看個最簡單的例子:
function Animal(name) {
this.name = name;
}
Animal.prototype.setName = function (name) {
this.name = name;
}
var animal = new Animal("wangwang");
這裡 Animal 是一個構造器,animal 是它的一個實例,帶有 name 屬性與 setName 方法。
關鍵特性在於:對 prototype 的任何修改,會即時反映到所有已存在的實例上。看這段:
function Animal(name) {
this.name = name;
}
var animal = new Animal("wangwang");
此刻 animal 只有 name。但只要之後補上:
Animal.prototype.setName = function (name) {
this.name = name;
}
animal 立刻也就有了 setName。它不是被複製進去的,而是查找屬性時「沿著鏈找到了」它。這個差異是理解後續一切的基礎。
所有對象最終都源自空對象——即 new Object() 或字面量 {} 產生的實例。空對象是「乾淨的」,只有預定義的屬性與方法;其他所有對象都繼承自它,因而共享這些預定義成員。原型本身也是一個對象實例。
於是原型的含義可以這樣表述:若構造器擁有一個原型對象 A,則由該構造器創建的每個實例都複製自 A,因此必然繼承 A 的全部屬性、方法與其他性質。
那麼「複製」具體怎麼做?歷史上有三種思路。
每構造一個實例,就從原型完整複製一份,新實例與原型佔用相同的記憶體空間。

好處是 obj1、obj2 與它們的原型「完全一致」,各自獨立。壞處顯而易見:記憶體消耗會隨實例數量線性激增,非常不經濟。
這個策略借自作業系統的動態連結庫技術——實體的記憶體區塊永遠是寫時才複製的。

我們只在系統中標明 obj1、obj2 等同於它們的原型。讀取時沿著指示去讀原型即可;一旦要寫入某個對象的屬性,就複製一份原型的映像出來,之後的操作指向該映像。

如此一來,創建實例與讀取屬性都不需要大量記憶體開銷,只在首次寫入時才分配空間。之後讀映像與讀原型的效率相同,不再有額外成本。不過對寫操作頻繁的系統而言,這套方案並不比方法一省。
把複製粒度從「整個原型」細化到「單個成員」。只有寫入某實例的某成員時,才把該成員複製進實例的映像中。例如執行 obj2.value = 10,會在 obj2 的成員列表裡產生一個名為 value 的項目。

obj2 仍然只是一個指向原型的引用,過程中沒有建立與原型等大的對象實例,因此寫入不觸發大量記憶體分配。代價是每個實例都要維護一張成員列表,這張列表遵循兩條規則:
三種方案中,讀遍歷的性能最佳。JavaScript 的原型繼承正是採用讀遍歷。這也解釋了為什麼修改原型能即時影響所有實例——因為實例從來就沒有真正持有那份屬性。
看最開頭那段代碼,熟悉 C++ 的人會有兩個疑問:沒有 class 關鍵字還能理解(畢竟有 function),但構造函數在哪裡?
其實 JavaScript 也有,只是叫「構造器」。使用 new 運算子的時候,就已經調用了構造器,並把 this 綁定到新產生的對象上。
如果把 new 拿掉會怎樣?
var animal = Animal("wangwang");
animal 會是 undefined。有人會說「本來就沒寫 return,當然是 undefined」。那我們補上 return:
function Animal(name) {
this.name = name;
return this;
}
猜猜現在 animal 是什麼?答案是 window。而且副作用是全域的 window 被污染了一個 name 屬性。原因在於:沒有 new 時,this 在預設情況下指向全域對象(非嚴格模式下即 window)。
要防範呼叫方漏寫 new,可以在函數開頭做個檢查:
function Animal(name) {
if (!(this instanceof Animal)) {
return new Animal(name);
}
this.name = name;
}
這樣無論有沒有 new,結果都一致。開啟嚴格模式('use strict')後,未綁定時的 this 會是 undefined 而非 window,也能提前暴露這類錯誤。
構造器的第二個作用是標明實例的歸屬。可以用 instanceof 判斷,但它在涉及繼承時對祖先類與直接類都返回 true,粒度太粗,不適合精確識別。constructor 屬性在 new 呼叫時預設指向當前構造器:
console.log(Animal.prototype.constructor === Animal); // true
換個角度想,prototype 在函數初始時其實是無值的,實作邏輯大致如下:
// __proto__ 是函數的內生成員,get_prototype() 是它的方法
var __proto__ = null;
function get_prototype() {
if (!__proto__) {
__proto__ = new Object();
__proto__.constructor = this;
}
return __proto__;
}
這種懶adiabatic初始化避免了「每宣告一個函數就馬上建立一個對象實例」的浪費。constructor 是可以被改寫的,這一點在後面會變成麻煩的來源。
先定義兩個構造器:
function Animal(name) {
this.name = name;
}
function Dog(age) {
this.age = age;
}
var dog = new Dog(2);
建立繼承只需一行——把子對象的原型指向父對象的實例(注意是實例,不是原型):
Dog.prototype = new Animal("wangwang");
此時 dog 同時擁有 name 與 age 兩個屬性。用 instanceof 驗證:
console.log(dog instanceof Animal); // true
console.log(dog instanceof Dog); // false
但這裡藏著一個 bug:
console.log(Dog.prototype.constructor === Animal); // true
console.log(Dog.prototype.constructor === Dog); // false
我們把 Dog.prototype 整體替換成了 Animal 的實例,連帶把原本指向 Dog 的 constructor 也覆蓋成了 Animal。結果就是無法再正確判斷 new 出來的實例究竟屬於誰。修法很簡單,補一行歸位:
Dog.prototype.constructor = Dog;
再驗一次:
console.log(dog instanceof Animal); // true
console.log(dog instanceof Dog); // true
兩邊都對了。這種做法最常用,安全性也比較好。
function Animal(name) {
this.name = name;
}
Animal.prototype.setName = function (name) {
this.name = name;
}
function Dog(age) {
this.age = age;
}
Dog.prototype = Animal.prototype;
好處是不必實例化父對象,省下資源。但弊端大於利:
constructor 指向了父對象;prototype 宣告的成員。上例中 Animal 的 name 屬性拿不到,但 setName 方法可以;因此不推薦。
繼承可以多層疊加,疊出來的結構就是原型鏈。要先區分兩種「鏈」:
__proto__,這是 JavaScript 對象系統的地基。它不可見,也不該被直接操作。prototype 屬性串接而成,也就是人們平常口說的「原型鏈」。照前面的寫法構造一組繼承:
function Animal(name) {
this.name = name;
}
function Dog(age) {
this.age = age;
}
var animal = new Animal("wangwang");
Dog.prototype = animal;
var dog = new Dog(2);
由於所有對象都繼承自空對象,我們便得到這樣一條鏈:

子對象的 prototype 指向父對象的實例,構成構造器原型鏈;子實例的內部 __proto__ 也指向父對象的實例,構成內部原型鏈。
屬性查找的模擬實作長這樣:
function getAttrFromObj(attr, obj) {
if (typeof (obj) === "object") {
var proto = obj;
while (proto) {
if (proto.hasOwnProperty(attr)) {
return proto[attr];
}
proto = proto.__proto__;
}
}
return undefined;
}
以在 dog 上找 name 為例:先查 dog 自身的成員列表,此時裡面只有 age,找不到;沿 __proto__ 走到 animal,命中並返回。若找的是一個不存在的屬性,則會一路向上到空對象仍無所獲,而空對象的 __proto__ 指向 null,迴圈條件 while (proto) 不再成立,查找結束並返回 undefined。
用 hasOwnProperty 而非直接取值判斷,是為了區分「自身擁有」與「沿鏈繼承而來」。若直接寫 if (proto[attr]),會把值為 0、''、false 的合法屬性誤判為不存在。
理想的狀態應該是:一個構造器產生的實例,其 constructor 指回自己。
(new obj()).constructor === obj;
但我們一旦改寫了 prototype,這個等式就被打破了。前面的解法是補一行:
Dog.prototype = new Animal("wangwang");
Dog.prototype.constructor = Dog;
表面沒問題了,可是又冒出新麻煩:我們再也回溯不了原型鏈。因為無法再從子類抵達父類,而內部屬性 __proto__ 按規矩是不該存取的。
SpiderMonkey 引擎提出過一個折衷方案:在所有創建的對象上加一個 __proto__ 屬性,它始終指向構造器所用的原型。這樣改動 constructor 不會影響 __proto__,維護起來方便。但仍有兩個問題:
__proto__ 本身可以被改寫,使用它依然有風險;還有一條路:保留原型上的 constructor 不動,改在子類構造器內部初始化實例自己的 constructor。
function Dog(age) {
this.constructor = arguments.callee;
this.age = age;
}
Dog.prototype = new Animal("wangwang");
這樣原型上的 constructor 仍指向父類(原型鏈得以保留),而每個實例自己身上有一份正確指向 Dog 的 constructor。兩邊的矛盾就此化解。代價是每次構造實例都要多寫一次屬性,效率略低。
ES5 提供了正式的答案:Object.getPrototypeOf() 可以在任何時刻取得對象的真實原型,無須依賴構造器,也無須自己維護外部鏈條。前面的屬性查找於是改寫為:
function getAttrFromObj(attr, obj) {
if (typeof (obj) === "object") {
do {
var proto = Object.getPrototypeOf(obj);
if (proto && proto.hasOwnProperty(attr)) {
return proto[attr];
}
} while (proto);
}
return undefined;
}
(原示範中把 Object.getPrototypeOf(dog) 寫死成了具體變數名,實用上應傳入的 obj;另外判斷條件加上 hasOwnProperty 才能避免把原型鏈上的同名屬性誤當成目標。)
這個方法只能在支援 ES5 的環境使用。若必須向下相容舊引擎,仍需回到 arguments.callee 那套方案。更實際的做法是把兩者整合封裝:偵測到 Object.getPrototypeOf 可用就用它,否則退回手動維護的鏈條。
把整篇收束成幾句話:
Child.prototype = new Parent(...),然後務必補上Child.prototype.constructor = Child 把構造器指向歸位。Child.prototype = Parent.prototype)省不了多少資源,卻會讓父子互相污染,應避免。instanceof 沿整條鏈判斷,適合回答「是不是某類的東西」;constructor 適合回答「究竟由誰造出來」。Object.getPrototypeOf 是取得原型鏈的正規途徑;ES6 的 class 語法糖背後仍然是這套原型機制,理解原型才不會把 class 當成魔法。