談物件導向就會想到類別、物件、封裝、繼承與多型。JavaScript 沒有 class 關鍵字的年代(ES6 之前),要「定義一個類」,工程師發展出了好幾套模式,各有取捨。《JavaScript 高階程式設計》一書對此有相當完整的整理,以下依序說明。
JavaScript 物件的屬性可以在建立之後動態附加,最直覺的寫法如下:
var oCar = new Object();
oCar.color = "red";
oCar.doors = 4;
oCar.showColor = function () {
alert(this.color);
};
oCar.showColor();
要把這種做法量產,就把整段包進函數裡回傳:
function createCar() {
var oCar = new Object();
oCar.color = "red";
oCar.doors = 4;
oCar.showColor = function () { alert(this.color); };
return oCar;
}
var ocar1 = createCar();
var ocar2 = createCar();
ocar1.color = "black";
ocar1.showColor();
這就是工廠方式:寫一個能生產特定形態物件的函數。順帶一提,JavaScript 物件的成員預設都是 public,沒有真正的 private。問題是它不符合 new Car() 的直覺,而且每次呼叫都重新建立屬性與函數,很浪費。
function Car(color, doors) {
this.color = color;
this.doors = doors;
this.showColor = function () { alert(this.color); };
}
var car1 = new Car("red", 4);
var car2 = new Car("blue", 4);
car1.showColor();
car2.showColor();
用 this 在函數內部掛屬性,搭配 new 建立物件,寫起來親切多了。但每 new 一次就把所有屬性和函數重建一次,car1 與 car2 各自擁有一套完全獨立的函數——而定義類的目的本就是共享方法與資料。這個缺口正好由原型模式補上。
function Car() {}
Car.prototype.color = "red";
Car.prototype.doors = 4;
Car.prototype.drivers = new Array("Tom", "Jerry");
Car.prototype.showColor = function () { alert(this.color); };
var car1 = new Car();
var car2 = new Car();
car1.drivers.push("stephen");
alert(car1.drivers); // Tom,Jerry,stephen
alert(car2.drivers); // Tom,Jerry,stephen ← 被連帶改動
也可以寫成 JSON 形式一次指派:
Car.prototype = {
color: "red",
doors: 4,
drivers: ["Tom", "Jerry"],
showColor: function () { alert(this.color); }
};
原型上的屬性由所有實例共享,方法確實只存在一份,但引用型別的屬性會共用同一個物件——car1 對陣列的修改會同步影響 car2,這通常不是我們想要的。此外原型無法接收建構參數,實例也無法擁有自己的初始值。
把兩者合起來:屬性放構造函數裡,方法放原型上。
function Car(color, doors) {
this.color = color;
this.doors = doors;
this.drivers = new Array("Tom", "Jerry"); // 每個實例獨立
}
Car.prototype.showColor = function () {
alert(this.color); // 所有實例共享
};
var car1 = new Car('red', 4);
var car2 = new Car('blue', 4);
car1.drivers.push("stephen");
alert(car1.drivers); // Tom,Jerry,stephen
alert(car2.drivers); // Tom,Jerry
alert(car1 instanceof Car); // true
這是最能兼顧「實例獨立資料」與「共享方法」的折衷,也是 ES6 之前最廣泛採用的寫法。缺點是視覺上屬性與方法被拆到兩處,讀起來不如其他語言的類別定義那樣整齊。
如果有人抱怨「屬性在函數裡、方法在外面」不合邏輯,動態原型法就是把方法也搬回構造函數內,但用旗標確保只定義一次:
function Car() {
this.color = "red";
this.doors = 4;
this.drivers = new Array("Tom", "Jerry");
if (typeof Car._initialized == "undefined") {
Car.prototype.showColor = function () { alert(this.color); };
// ...其他方法
Car._initialized = true;
}
}
關鍵是 typeof Car._initialized == "undefined" 這個判斷。第一次建立實例時值未定義,於是掛上所有方法並把旗標設為 true;之後再建立實例時,判斷為 false,就跳過重新定義。如此一來,方法只會被建立並賦值一次,同時語法上更接近傳統 OOP 語言的類別定義,視覺封裝的效果也更好。
function Car() {
var oTempCar = new Object();
oTempCar.color = "red";
oTempCar.doors = 4;
oTempCar.mpg = 23;
oTempCar.showColor = function () { alert(this.color); };
return oTempCar;
}
var oCar = new Car();
它看起來像真正的構造函數,但因為函數內部自己 new 了一個物件並回傳,外層的 new 實際上被忽略。這招是前幾種方式都無法套用時的變通手法,在方法內部管理上仍有與工廠方式相同的問題,不建議作為常規選擇。
// 靜態類:以立即執行函數建立單例
var CarCollection = new function () {
var _carCollection = new Array(); // 私有的內部狀態
this.Add = function (objCar) { alert('Add'); };
this.Get = function (carid) { alert('Get'); };
};
// 物件直接量:不需要 new,本身就是唯一實例
var Car = {
color: 'red',
doors: 4,
showColor: function () { alert(this.color); }
};
Car.showColor();
目前最主流的是混合構造函數/原型模式,動態原型在功能上與它等價且也很受歡迎,兩者擇一即可。不建議單獨使用純構造函數或純原型方式,因為那會分別帶來函數重複建立、以及引用屬性被共用這兩個實際問題。當然,如果執行環境允許,直接用 ES6 的 class 語法即可——它本質上就是原型模式的一層語法糖,但可讀性提升非常明顯。