JavaScript 沒有 class 關鍵字(ES6 之前),卻要做物件導向。這個落差催生了各種建立物件與實作繼承的模式。本文依序走過:建立物件的五種方式、原型的運作、以及繼承的七種做法,最後說明為什麼「寄生組合式繼承」被視為最優解。
var box = new Object();
box.name = 'lee';
box.age = 100;
box.run = function () { return this.name + this.age + '運行中...'; }
想建第二個類似物件,就得把整段複製一遍。
function createObject(name, age) {
var obj = new Object();
obj.name = name;
obj.age = age;
obj.run = function () { return this.name + this.age + "運行中..."; };
return obj;
}
var box1 = createObject("lee", 100);
var box2 = createObject("jack", 200);
缺點是無法辨識物件身分——typeof box1 只會回傳 "object",看不出它是哪個類型的實例。
function Box(name, age) {
this.name = name;
this.age = age;
this.run = function () { return this.name + this.age + "運行中..."; };
}
var box1 = new Box("lee", 100);
console.log(box1 instanceof Box); // true,身分清楚
與工廠模式的三點差異:沒有明確建立物件(不用 new Object)、直接把屬性與方法賦值給 this、沒有 return 語句。
慣例:函式名稱首字母大寫,且必須搭配 new 呼叫。若忘記 new,this 會指向全域物件,屬性被寫到 window 上,且回傳 undefined。
用建構函式時,每個實例都會重新建立一份方法。因為函式在 JavaScript 中就是物件,每定義一次函式等於建立一個新物件。這造成兩份 box1.run 與 box2.run 雖然內容相同,卻是不同的參照:
var b1 = new Box('a', 1), b2 = new Box('b', 2);
console.log(b1.run === b2.run); // false
這正是原型要解決的問題。
每個函式都有一個 prototype 屬性,指向一個物件。它的用途是存放可讓該型別所有實例共享的屬性與方法。
function Box() {}
Box.prototype.name = 'Lee';
Box.prototype.age = 100;
Box.prototype.run = function () { return this.name + this.age + '運行中...'; };
var box1 = new Box();
var box2 = new Box();
console.log(box1.run === box2.run); // true,共用同一個參照
讀取 box1.name 時:
__proto__ 爬到原型物件上找。Object.prototype,最後是 null。因此實例屬性會遮蔽(shadow)原型屬性:
var b1 = new Box();
console.log(b1.name); // Lee(來自原型)
b1.name = 'jack';
console.log(b1.name); // jack(實例自己的)
delete b1.name;
console.log(b1.name); // Lee(又看到原型了)
__proto__ 是實例指向原型的指針(標準做法是 Object.getPrototypeOf())。constructor 是原型上的屬性,指回建構函式本身。
判斷原型關係用 isPrototypeOf():
Box.prototype.isPrototypeOf(box1); // true
console.log(box.hasOwnProperty('name')); // 只問實例自身
console.log('name' in box); // 實例或原型有就算 true
Box.prototype = {
constructor: Box, // 必須手動補回,否則會指向 Object
name: 'Lee',
age: 100,
run: function () { return this.name + this.age; }
};
整體覆寫原型會切斷 constructor 的正確指向,因為字面量 {} 本身就是建立一個新物件,其 constructor 預設為 Object。若不補回,box.constructor == Box 會是 false。
另一個後果:覆寫原型會切斷與既有實例的連結。覆寫之前建立的物件仍指向舊的原型物件。
Box.prototype.family = ['father', 'mother'];
var b1 = new Box(), b2 = new Box();
b1.family.push('sister');
console.log(b2.family); // ["father","mother","sister"] — 被汙染了
所有實例共用同一個陣列,一邊改動其他邊全變。此外原型模式也無法在建構時傳入參數初始化。
function Box(name, age) { // 不共享的屬性放這裡
this.name = name;
this.age = age;
this.family = ['father', 'mother'];
}
Box.prototype = { // 共享的方法放這裡
constructor: Box,
run: function () { return this.name + this.age + this.family; }
};
把原型封裝進建構函式裡,只在第一次執行時初始化:
function Box(name, age) {
this.name = name;
this.age = age;
if (typeof this.run !== "function") {
Box.prototype.run = function () { return this.name + this.age; };
}
}
注意:此模式下不可再用字面量覆寫原型,否則會切斷連結。
本質是工廠模式包在建構函式外殼裡,能傳參,但無法可靠辨識物件身分:
function Box(name, age) {
var obj = new Object();
obj.name = name;
obj.age = age;
obj.run = function () { return this.name + this.age; };
return obj;
}
把父類型的實例賦值給子類型的 prototype:
function Box() { this.name = 'Lee'; }
function Desk() { this.age = 100; }
Desk.prototype = new Box(); // 關鍵一行
var desk = new Desk();
console.log(desk.age); // 100(自己的)
console.log(desk.name); // Lee(從 Box 繼承而來)
可以再串一層:Table.prototype = new Desk();,形成 Box → Desk → Table 的鏈條,最終都繼承自 Object。
問題:引用型別共享(與原型模式同一個病),且無法向父類建構函式傳參。
在子類建構函式內呼叫父類,用 call 改變 this:
function Box(age) {
this.name = ['Lee', 'Jack'];
this.age = age;
}
function Desk(age) {
Box.call(this, age); // 繼承 Box,並成功傳參
this.height = 175;
}
var desk = new Desk(200);
desk.name.push('AAA'); // 只影響 desk 自己,不汙染原型
解決了引用共享與傳參問題,但方法無法複用——每次都重新建立,函式復用無從談起。
function Box(age) {
this.name = ['Lee', 'Jack'];
this.age = age;
}
Box.prototype.run = function () { return this.name + this.age; }; // 方法給原型
function Desk(age) {
Box.call(this, age); // 屬性用借用建構函式
}
Desk.prototype = new Box(); // 方法用原型鏈
var desk = new Desk(100);
console.log(desk.run());
這是最常用的繼承模式,但仍有個缺陷:Box 被呼叫了兩次——一次在 Desk.prototype = new Box(),一次在 Box.call(this, age)。
function obj(o) {
function F() {}
F.prototype = o;
return new F();
}
var box = { name: 'Lee', arr: ['brother', 'sister'] };
var box1 = obj(box);
box1.arr.push('father'); // 引用型別仍然共享
本質是對傳入物件做一次淺複製,不必預先定義建構函式。ES5 之後直接用 Object.create(box) 即可。
原型式加上工廠模式,目的是把建立物件的過程封裝起來,回傳增強後的物件。引用共享的問題依舊存在。
思路:用借用建構函式繼承屬性,用原型鏈的淺複製繼承方法,藉此避免呼叫父類建構函式兩次。
function obj(o) {
function F() {}
F.prototype = o;
return new F();
}
function inheritPrototype(subType, superType) {
var f = obj(superType.prototype); // 複製父類原型,不執行建構函式
f.constructor = subType; // 修正 constructor 指向
subType.prototype = f; // 指定為子類原型
}
function Box(name) {
this.name = name;
this.arr = ['brother', 'sister'];
}
Box.prototype.run = function () { return this.name; };
function Desk(name, age) {
Box.call(this, name); // 只呼叫一次,屬性獨立
this.age = age;
}
inheritPrototype(Box, Desk);
var desk = new Desk('Lee', 100);
desk.arr.push('father');
console.log(desk.run()); // Lee
它結合了組合繼承的優點,又消除了多餘的一次建構函式呼叫,是衡量「繼承是否正確實作」的標準答案。ES6 的 class extends 底層就是這個模式。
物件在 JavaScript 中是動態的,執行時可以增強,而非嚴格定義的實體。工廠模式用函式建立並回傳物件,後來被建構函式取代;建構函式能自定義引用類型並用 new 建立實例,但成員無法複用;原型模式透過 prototype 指定共享成員,實務上與建構函式組合使用——建構函式管實例屬性,原型管共享方法。
原型鏈由「把一個類型的實例賦值給另一個建構函式的 prototype」構成,子類型能存取超類型的所有成員,但共享問題使他不適合單獨使用。借用建構函式在子類型建構時呼叫超類型,讓每個實例擁有獨立屬性。組合繼承結合兩者,是最常用的模式;寄生組合式繼承則進一步消除重複呼叫,是基於類型的繼承中最有效率的做法。
新專案直接用 ES6 class 與 extends,語法清楚且就是上述模式的標準化;需要混入多個行為時用 Object.assign 搭配 mixin;只有在維護舊程式或面試需要說明原理時,才需要手寫這些模式。理解它們的價值在於——你會知道 class 底下正在發生什麼事。