在 JavaScript 的世界裡談物件導向,繞不開兩個前提:其一,JavaScript 是一門基於原型的物件導向語言;其二,實務上大量存在的寫法是在模擬類別語言的物件導向方式。
為什麼要模擬類別語言?我的看法是:原型模式在特定情境下確實便利,但在複雜應用中,純原型系統在抽象性與繼承性上力有未逮。而 JavaScript 又是唯一被各大瀏覽器原生支援的腳本語言,於是各路高手不得不想辦法提升它的便利性,結果就是程式碼越寫越像類別語言,反而掩蓋了 JavaScript 原型系統的本質。
原型模式與類模式都是一種程式設計泛型,也就是方法論;近來蔚為風潮的函數式程式設計同樣也是一種泛型。JavaScript 之父 Brendan Eich 從一開始就沒打算加入類別概念,而是借鑑了 Self 與 Smalltalk 這兩門基於原型的語言。
既然同為物件導向,就得有建立物件的方法。類語言中,物件由模板建立:先定義類作為現實世界的抽象,再由類 instance 化物件。而在原型語言中,物件是以複製另一個物件的方式誕生,被複製的母體稱為原型物件。
複製的關鍵在於語言是否提供原生複製能力。ECMAScript 5 的 Object.create 就肩負這個職責:
var person = {
name: "tree",
age: 25,
say: function () {
console.log("I'm tree.");
}
};
var cloneTree = Object.create(person);
console.log(cloneTree);
原型模式的目的並不在得到一個一模一樣的複製品,而是提供一種便捷的建構方式(出自《JavaScript 設計模式與開發實踐》)。但由於語言設計的歷史包袱,JavaScript 的原型存在諸多矛盾,某些語法看起來就像類語言,反而遮蔽了原型機制(出自《JavaScript 語言精粹》):
function Person(name, age) {
this.name = name;
this.age = age;
}
var p = new Person('tree', 25);
實際上,當一個函式物件被建立時,Function 建構器產生的函式物件會執行類似這樣的程式:
this.prototype = { constructor: this }
新的函式物件被賦予一個 prototype 屬性,其值是一個帶有 constructor 且指向該函式本身的物件。而對函式使用 new 時,這個 prototype 的值就被當作原型物件,用來複製出新物件。若把 new 當成一個方法來看,它的執行過程是:
Function.prototype.new = function () {
// 以 prototype 屬性值作為原型物件複製出新物件
var that = Object.create(this.prototype);
// 改變函式中 this 的指向,指向這個新物件
var other = this.apply(that, arguments);
// 若回傳值不是物件,則回傳新複製的物件
return (other && typeof other === 'object') ? other : that;
};
由此可見,new 呼叫函式表面上像模板 instance 化,本質仍是「以原型物件複製出新物件」。而新物件能繼承原型的一切方法與屬性,加上 new 的特性,這就成了用原型模擬類語言的基石。
抽象
依 JavaScript 的特性,慣例是把欄位放在建構函式(實為被 new 呼叫的普通函式)中,把方法放在 prototype 上:
function Person(name, age) {
this.name = name;
this.age = age;
}
Person.prototype.say = function () {
console.log("Hello, I'm " + this.name);
};
繼承
繼承是 OO 語言中最常被討論的概念。多數 OO 語言支援兩種繼承:介面繼承(只繼承方法簽名)與實作繼承(繼承實際方法)。ECMAScript 無法實作介面繼承,只支援實作繼承,且主要依賴原型鏈(《JavaScript 高級程式設計》6.3 節)。書中探討了組合繼承、原型繼承、寄生繼承、寄生組合繼承等模擬方式,最終寄生組合式成為所有類式繼承模擬的基礎:
function Person(name, age) {
this.name = name;
this.age = age;
}
Person.prototype.say = function () {
console.log("Hello, I'm " + this.name);
};
function Employee(name, age, major) {
Person.apply(this, arguments);
this.major = major;
}
Employee.prototype = Object.create(Person.prototype);
Employee.prototype.constructor = Employee;
Employee.prototype.sayMajor = function () {
console.log(this.major);
};
書中只給了單繼承方案,多繼承得自己想辦法。而多繼承本身就困難:支援多繼承的語言都會遇上著名的菱形問題(Diamond Problem)。若 O 有一個方法 foo,被 A 與 B 各自覆寫而 C 未覆寫,那麼 C 呼叫 foo 時究竟該執行 A 版還是 B 版?

因此多數語言並不支援多繼承,例如 Java 採「單繼承 + 介面」。JavaScript 連介面都沒有,怎麼辦?答案是鴨子式型別判斷,落到程式碼上就是混入(mixin)。原理非常樸素:
function mixin(t, s) {
for (var p in s) {
t[p] = s[p];
}
}
值得一提的是,dojo 用 MRO(Method Resolution Order,方法解析順序)的方式解決了多繼承問題。
理清了原理,作為一個愛折騰的開發者,我希望有更簡便的方式建立類別,目標有四:
prototype 屬性最終整理出這套類別建立工具 O.js:
(function (global) {
var define = global.define;
if (define && define.amd) {
define([], function () { return O; });
} else {
global.O = O;
}
function O() {};
O.derive = function (sub) {
var parent = this;
sub = sub ? sub : {};
var o = create(parent);
var ctor = sub.constructor || function () {}; // 如何呼叫父類的建構函式?
var statics = sub.statics || {};
var ms = sub.mixins || [];
var attrs = sub.attributes || {};
delete sub.constructor;
delete sub.mixins;
delete sub.statics;
delete sub.attributes;
// 處理繼承關係
ctor.prototype = o;
ctor.prototype.constructor = ctor;
ctor.superClass = parent;
// 利用 defineProperties 處理 Attributes
Object.defineProperties(ctor.prototype, attrs);
// 靜態屬性
mixin(ctor, statics);
// 混入其他屬性與方法,注意這裡的屬性是所有 instance 都能存取並修改的
mixin(ctor.prototype, sub);
// 以 mixin 模擬多繼承
for (var i = 0, len = ms.length; i < len; i++) {
mixin(ctor.prototype, ms[i] || {});
}
ctor.derive = parent.derive;
// _super 函式
ctor.prototype._super = function (f) {
return parent.prototype[f].apply(this, Array.prototype.slice.call(arguments, 1));
};
return ctor;
};
function create(clazz) {
var F = function () {};
F.prototype = clazz.prototype;
return new F();
}
function mixin(t, s) {
for (var p in s) {
t[p] = s[p];
}
}
})(window);
建立類別的寫法如下:
var Person = O.derive({
constructor: function (name) { // 建構函式
this.setInfo(name);
},
statics: { // 靜態變數
declaredClass: "Person"
},
attributes: { // 模擬 C# 中的屬性
Name: {
set: function (n) {
this.name = n;
console.log(this.name);
},
get: function () {
return this.name + "Attribute";
}
}
},
share: "asdsaf", // 位於原型上的變數,所有 instance 共享
setInfo: function (name) { // 方法
this.name = name;
}
});
var p = new Person('lzz');
console.log(p.Name); // lzzAttribute
console.log(Person);
繼承則顯得相當直觀:
var Employee = Person.derive({ // 由父類衍生
constructor: function (name, age) {
this.setInfo(name, age);
},
statics: {
declaredClass: "Employee"
},
setInfo: function (name, age) {
this._super('setInfo', name); // 呼叫父類同名方法
this.age = age;
}
});
var e = new Employee('lll', 25);
console.log(e.Name); // lllAttribute
console.log(Employee);
理解原型機制之後,這些看似神奇的語法糖其實都很透明——它們不過是原型鏈、混入與 Object.create 的組合技。掌握底層原理,框架層的設計自然就有跡可循。