JavaScript 是面向物件語言,而 C#、Java 這類靜態語言都有固定的 class 語法。JavaScript 的不同之處在於,它能用好幾種方式自己實作類與物件。這些方式並非毫無關聯,而是逐步演進、各自解決前一種痛點的結果。
寫一個回傳特定物件的工廠函式:
function createCar(sColor, iDoors, iMpg) {
var oTempCar = new Object;
oTempCar.color = sColor;
oTempCar.doors = iDoors;
oTempCar.mpg = iMpg;
oTempCar.showColor = function() {
alert(this.color);
}
return oTempCar;
}
var oCar1 = createCar("red", 4, 23);
var oCar2 = createCar("blue", 3, 25);
oCar1.showColor();
oCar2.showColor();
每次呼叫都會產生一個新物件,問題在於 showColor 函式也被重新建立了一次。每個物件都擁有自己的函式版本,而事實上它們共享同一份實作。
的解法是把它抽到外面定義,再讓物件指向它:
function showColor() {
alert(this.color);
}
function createCar(sColor, iDoors, iMpg) {
var oTempCar = new Object;
oTempCar.color = sColor;
oTempCar.doors = iDoors;
oTempCar.mpg = iMpg;
oTempCar.showColor = showColor; // 指向共用函式
return oTempCar;
}
var oCar1 = createCar("red", 4, 23);
var oCar2 = createCar("blue", 3, 25);
oCar1.showColor();
oCar2.showColor();
功能上沒問題了,但 showColor 現在是掛在類外面的游離函式,看起來完全不像是這個物件的方法。於是有了下一種寫法。
function Car(sColor, iDoors, iMpg) {
this.color = sColor;
this.doors = iDoors;
this.mpg = iMpg;
this.showColor = function() {
alert(this.color);
}
}
var oCar1 = new Car("red", 4, 23);
var oCar2 = new Car("blue", 3, 25);
構造函式內部不建立物件,而是用 this 關鍵字。用 new 呼叫時,執行第一行之前會先建立一個物件,只有透過 this 才能存取它。
但老問題還在:每個物件依然各自建立一份 showColor。要共用函式,就得回到原型。
利用物件的 prototype 屬性——它可以視為建立新物件時所依賴的原型。這裡用空構造函式來命名類別,再把所有屬性與方法掛到 prototype 上:
function Car() {}
Car.prototype.color = "red";
Car.prototype.doors = 4;
Car.prototype.mpg = 23;
Car.prototype.drivers = new Array("Mike", "Sue");
Car.prototype.showColor = function() {
alert(this.color);
}
原型方式有兩個明顯缺陷。
第一,無法在建構時初始化。必須先建立物件,之後才能改屬性預設值,沒辦法在 new 的時候直接傳入想要的值。
第二,當屬性是物件時會共用。函式共享不成問題,但物件共享會出事:
var oCar1 = new Car();
var oCar2 = new Car();
oCar1.drivers.push("Matt");
alert(oCar1.drivers); // "Mike,Sue,Matt"
alert(oCar2.drivers); // "Mike,Sue,Matt" ← 也被改到了
因為 drivers 只是指向同一個陣列的參考,所有實例事實上共用同一份資料。
思路很清晰:非函式屬性放構造函式,函式屬性放原型。這樣函式只被建立一次,而每個物件都擁有自己的物件屬性實例。
function Car(sColor, iDoors, iMpg) {
this.color = sColor;
this.doors = iDoors;
this.mpg = iMpg;
this.drivers = new Array("Mike", "Sue"); // 每個實例獨立
}
Car.prototype.showColor = function() { // 所有實例共用
alert(this.color);
}
var oCar1 = new Car("red", 4, 23);
var oCar2 = new Car("blue", 3, 25);
oCar1.drivers.push("Matt");
alert(oCar1.drivers); // "Mike,Sue,Matt"
alert(oCar2.drivers); // "Mike,Sue" ← 互不干擾
兩個問題一次解決。這也是 ES6 之前最受推薦的寫法。
混合方式唯一的遺憾是 showColor 定義在類外面,視覺上不夠封裝。動態原型方式把方法寫回構造函式內部,並用一個旗標確保只初始化一次:
function Car(sColor, iDoors, iMpg) {
this.color = sColor;
this.doors = iDoors;
this.mpg = iMpg;
this.drivers = new Array("Mike", "Sue");
if (typeof Car._initialized == "undefined") {
Car.prototype.showColor = function() {
alert(this.color);
}
Car._initialized = true;
}
}
如此一來 Car.prototype.showColor 只會被建立一次,整體結構也更接近其他語言的類別定義。
這是一種變通做法,在構造函式內部 new 一個物件並回傳:
function createCar() {
var oTempCar = new Object;
oTempCar.color = "red";
oTempCar.doors = 4;
oTempCar.mpg = 23;
oTempCar.showColor = function() {
alert(this.color);
};
return oTempCar;
}
var car = new Car();
因為 Car() 內部呼叫了 new,外層的第二個 new 會被自動忽略,真正被傳回變數的是內部建立的物件。這種寫法在物件方法的內部管理上有著與傳統方式相同的問題,除非萬不得已,不建議採用。
以上六種寫法都是 ES6 問世前的歷史產物。現在一律建議使用 class 語法搭配 extends,語意清楚、繼承鏈明確,也不容易踩到原型共用的坑。理解這些演進過程的價值在於:當你閱讀老專案或第三方庫時,能一眼看出對方用的是哪一種模式、背後的取捨是什麼。