JavaScript 是一門面向對象的語言,一句被引用到爛的話是「萬物皆對象」。面向對象的三大特性——封裝、繼承、多態——在這裡都有體現。本文聚焦其中最容易被誤解的一項:繼承。
關鍵差異在於:C++ 的繼承基於類,而 JavaScript 的繼承基於原型。這個選擇深刻影響了整個語言的對象系統。
原型的作用可以類比 C++ 裡的類,同樣保存了對象共享的屬性和方法:
function Animal(name) {
this.name = name;
}
Animal.prototype.setName = function(name) {
this.name = name;
};
var animal = new Animal("wangwang");
這裡 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 的屬性、方法與其他性質。
接下來的問題是:這種「復制」在底層如何實現?歷史上有三種策略。
每構造一個實例,都從原型完整複製一份,新實例與原型佔用相同的內存空間。

這確實讓實例與原型「完全一致」,但代價高昂——內存消耗會隨實例數量線性甚至更快增長,非常不經濟。
這個策略借鑑自一致性欺騙系統,經典案例就是操作系統中的動態鏈接庫(DLL),其內存區總是寫時復制的。

系統只需標明 obj1、obj2 等價於它們的原型,讀取時順著指示去讀原型即可;當需要寫入某個對象的屬性時,才複製一份原型的映像出來,讓後續操作指向該映像。

優點是創建實例和讀取屬性時幾乎沒有內存開銷,只在首次寫入時才分配內存。此後訪問映像與訪問原型的效率一致。但對於寫操作頻繁的系統,這種方式並不比方法一划算。
把復制的粒度從「整個原型」縮小到「單個成員」:僅當寫某個實例的成員時,才把該成員信息複製進實例映像。

例如執行 obj2.value = 10 時,會產生一個名為 value 的屬性放在 obj2 的成員列表中。這樣 obj2 依然只是一個指向原型的引用,過程中沒有創建與原型等大的對象實例,寫操作不觸發大量內存分配。
代價是每個實例都要維護一張成員列表,它遵循兩條規則:
· 讀取時首先訪問該成員列表。
· 若列表中沒有指定屬性,則沿著原型鏈向上遍歷,直到原型為空或找到目標屬性。
三種方案中,讀遍歷的性能最優。JavaScript 的原型繼承正是採用讀遍歷。
熟悉 C++ 的人看到前面的代碼一定會疑惑:構造函數在哪裡?實際上 JavaScript 也有類似機制,只是叫做構造器。使用 new 運算符時,其實已經調用了構造器,並把 this 綁定到新創建的對象上。
如果漏寫 new 會怎樣?
var animal = Animal("wangwang");
animal 將是 undefined。有人會說「沒有返回值自然是 undefined」,那把定義改一下再看:
function Animal(name) {
this.name = name;
return this;
}
此時 animal 變成了 window!差別只在於我們無意間給 window 擴充了一個 name 屬性。原因是在沒有指定 this 的情況下,它默認指向最頂層的 window。只有透過 new 呼叫,才能正確觸發構造器行為。
怎樣防止調用方漏掉 new?做個小檢查即可:
function Animal(name) {
if (!(this instanceof Animal)) {
return new Animal(name);
}
this.name = name;
}
constructor 能告訴你實例是由哪個構造器產生的。雖然 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__;
}
這樣做的好處是避免了每聲明一個函數就創建一個對象實例,節省開銷。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 兩個屬性。
console.log(dog instanceof Animal); // true
console.log(dog instanceof Dog); // false
但這帶來一個副作用:
console.log(Dog.prototype.constructor === Animal); // true
console.log(Dog.prototype.constructor === Dog); // false
構造器指向被改寫了,我們再也無法判斷實例究竟屬於誰。修復方式很簡單,補一句即可:
Dog.prototype.constructor = Dog;
再看一次:
console.log(dog instanceof Animal); // false
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 方法能。
· 最致命的是,對子對象 prototype 的任何修改都會直接影響父對象,兩邊的實例都會受牽連。
因此這種方法不推薦使用。
繼承可以多層嵌套,在 JS 中這就構成了原型鏈。
首先要區分兩種「鏈」:一個實例至少應擁有指向原型的 __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,找到 name 並返回。若查找的是一個不存在的屬性,則會繼續向上走到空對象,仍未找到,再往上而空對象的 __proto__ 指向 null,查找終止,返回 undefined。
回到方法一留下的問題:子對象實例的 constructor 指向了父對象。好處是可以透過 constructor 訪問原型鏈,壞處是與構造器的初衷背道而馳——一個對象產生的實例,constructor 本應指向它自己:
(new obj()).prototype.constructor === obj;
我們前面给出的修復是:
Dog.prototype = new Animal("wangwang");
Dog.prototype.constructor = Dog;
看似完美,但同時又帶來新問題:我們再也無法回溯原型鏈了,因為找不到父對象,而內部原型鏈的 __proto__ 是無法直接訪問的。
SpiderMonkey 在每個創建的對象上添加了一個名為 __proto__ 的屬性,該屬性始終指向構造器所用的原型。這樣一來,對 constructor 的任何修改都不會影響 __proto__ 的值,constructor 的維護變得容易。
但它有兩個問題:
· __proto__ 是可以被重寫的,使用它仍有風險。
· 它是 SpiderMonkey 的特殊處理,在其他引擎(如 JScript)中無法使用。
另一種思路是:保持原型的 constructor 屬性不動,改在子類構造器函數內部為每個實例設置 constructor。
function Dog(age) {
this.constructor = arguments.callee;
this.age = age;
}
Dog.prototype = new Animal("wangwang");
這樣,所有子對象實例的 constructor 都正確指向該對象,而原型的 constructor 則指向父對象。缺點是效率較低——每次構造實例都要重寫 constructor 屬性,但毫無疑問能有效解決前述矛盾。
ES5 正視了這個問題,提供了 Object.getPrototypeOf(),可以在任意時刻獲得一個對象的真實原型,而無須訪問構造器或維護外部的原型鏈:
function getAttrFromObj(attr, obj) {
if (typeof(obj) === "object") {
do {
var proto = Object.getPrototypeOf(obj);
if (proto[attr]) {
return proto[attr];
}
} while (proto);
}
return undefined;
}
注意示例中原寫法誤用了固定的 dog,實用時應改為傳入的 obj。
這種方式僅能在支援 ES5 的環境中使用。為了向後兼容,仍需保留前一種方案;更成熟的做法是把兩者整合封裝——判斷 Object.getPrototypeOf 是否存在,不存在時退回 __proto__ 或構造器內初始化的方式。
原型繼承的精妙之處在於用「共享 + 查找」替代了「複製」:實例只存自己的差異部分,其餘沿鏈回溯。理解了三種復制策略的取捨、constructor 指向的由來與修復、以及原型鏈的查找路徑,JavaScript 的對象系統就不再是一個需要死記硬背的黑盒。而在今天的實際開發中,直接寫 class 與 extends 即可——它們本質上就是原型繼承的語法糖,但知道底層發生什麼,遇到繼承相關的怪問題時才知道該往哪裡看。