ES6 的 class 語法出現之前,JavaScript 沒有正式的類聲明,工程師們用函數、對象與原型湊出了好幾套方案。理解這些寫法,才能真正看懂原型鏈是怎麼運作的。下面逐一拆解。
最直觀的一種:函數內部造一個對象,掛好屬性和方法後返回。
function Car() {
var ocar = new Object;
ocar.color = "blue";
ocar.doors = 4;
ocar.showColor = function () {
document.write(this.color);
};
return ocar;
}
var car1 = Car();
var car2 = Car();
每次呼叫都會產出一個屬性完全相同的新對象。稍作改造,就能透過參數控制初始值:
function Car(color, door) {
var ocar = new Object;
ocar.color = color;
ocar.doors = door;
ocar.showColor = function () {
document.write(this.color);
};
return ocar;
}
var car1 = Car("red", 4);
var car2 = Car("blue", 4);
car1.showColor(); // 輸出 "red"
car2.showColor(); // 輸出 "blue"
問題在於:每次呼叫 Car() 都會重新創建一份 showColor(),而實際上所有對象共享的是同一個函數。把方法提到外部定義、再指向它,可以避免這種浪費:
function showColor() {
alert(this.color);
}
function Car() {
var ocar = new Object();
ocar.color = color;
ocar.doors = door;
ocar.showColor = showColor;
return ocar;
}
但這樣一來,方法看起來就不像是「這個類的方法」了,語義上很彆扭。
function Car(color, door) {
this.color = color;
this.doors = door;
this.showColor = function () {
alert(this.color);
};
}
var car1 = new Car("red", 4);
var car2 = new Car("blue", 4);
注意函數體內沒有創建對象,全部改用 this 賦值——因為調用時對象已經由 new 造好了,函數內部只能透過 this 去訪問它。用 new 之後確實像那麼回事了,但它和工廠方式有一樣的毛病:每次調用都會為對象生成一套自己的方法。
利用函數的 prototype 屬性,先用空函數佔住類名,再把所有成員掛到原型上。
function Car() {
}
Car.prototype.color = "red";
Car.prototype.doors = 4;
Car.prototype.showColor = function () {
alert(this.color);
};
var car1 = new Car();
var car2 = new Car();
調用構造函數時,原型上的所有屬性會立刻對新對象可見,且各實例持有的都是指向同一個 showColor() 的指針,語法上看起來就像同一個類。
缺點也很明確:構造函數沒有參數,無法在創建時初始化屬性,只能在對象生成後再逐一改寫默認值。更嚴重的是,當原型屬性是一個引用類型時,所有實例會共用同一份數據:
function Car() {
}
Car.prototype.color = "red";
Car.prototype.doors = 4;
Car.prototype.arr = new Array("a", "b");
Car.prototype.showColor = function () {
alert(this.color);
};
var car1 = new Car();
var car2 = new Car();
car1.arr.push("cc");
alert(car1.arr); // a,b,cc
alert(car2.arr); // a,b,cc —— 被連帶修改了
因為數組是引用值,兩個對象指向的是同一個數組,改動自然互相可見。
把兩者結合起來,就能像其他語言那樣寫類:用構造函數定義非函數屬性,用原型定義方法。
function Car(color, door) {
this.color = color;
this.doors = door;
this.arr = new Array("aa", "bb");
}
Car.prototype.showColor = function () {
alert(this.color);
};
var car1 = new Car("red", 4);
var car2 = new Car("blue", 4);
car1.arr.push("cc");
alert(car1.arr); // aa,bb,cc
alert(car2.arr); // aa,bb —— 互不干擾
每個實例擁有自己的屬性副本,方法則共享一份,兩種問題一併解決。
原理與混合方式幾乎一致,唯一的差別是給原型掛方法的位置——寫在構造函數內部,並用一個標志位保證只執行一次。
function Car(color, door) {
this.color = color;
this.doors = door;
this.arr = new Array("aa", "bb");
if (typeof Car._initialized == "undefined") {
Car.prototype.showColor = function () {
alert(this.color);
};
Car._initialized = true;
}
}
首次調用時檢測 Car._initialized 是否已定義,未定義就掛方法並置位。這樣既保留了把所有邏輯寫在同一個函數裡的可讀性,又確保方法只被創建一次。
它做的事情是:造一個「假」構造函數,實際返回另一種對象的新實例。
function Car() {
var ocar = new Object();
ocar.color = "red";
ocar.doors = 4;
ocar.showColor = function () {
alert(this.color);
};
return ocar;
}
與工廠方式的唯一區別是:調用它時會帶上 new 運算符。由於函數顯式返回了對象,new 創建的那個實例實際上被丟棄了。
目前實踐中最通行的是構造函數/原型混合方式,動態原型方式同樣流行,功能上與前者等價,只是把方法定義收攏進了同一個函數體。至於純工廠、純原型這些方案,主要價值在於幫助我們理解各自的短板從何而來。
最後補一句:如果項目已經能用 ES6,直接寫 class 即可——它本質上就是原型繼承的語法糖,背後運行的仍是這套機制。