JavaScript 沒有 class 關鍵字(在 ES6 之前),繼承得靠原型鏈搭配各種技巧湊出來。以下依實用度排序說明。
// 定義 SuperClass,有一個屬性與一個方法
function SuperClass() {
this.property = true;
}
SuperClass.prototype.getSuperValue = function () {
return this.property;
};
// 定義 SubClass
function SubClass() {
this.subproperty = false;
}
// 讓 SubClass 繼承 SuperClass
SubClass.prototype = new SuperClass();
// 為 SubClass 加上自己的方法
SubClass.prototype.getSubValue = function () {
return this.subproperty;
};
var instance = new SubClass();
alert(instance.getSuperValue());
第一種方式用 instanceof,它會沿著原型鏈測試是否有對應的建構函式:
alert(instance instanceof Object); // true alert(instance instanceof SuperClass); // true alert(instance instanceof SubClass); // true
第二種方式用 isPrototypeOf(),直接測試原型鏈中出現的原型:
alert(Object.prototype.isPrototypeOf(instance)); // true alert(SuperClass.prototype.isPrototypeOf(instance)); // true alert(SubClass.prototype.isPrototypeOf(instance)); // true
這是最容易出錯的地方:必須先指定 prototype,再往上加方法。
function SuperClass() {
this.property = true;
}
SuperClass.prototype.getSuperValue = function () {
return this.property;
};
function SubClass() {
this.subproperty = false;
}
// 先繼承
SubClass.prototype = new SuperClass();
// 再加新方法
SubClass.prototype.getSubValue = function () {
return this.subproperty;
};
// 再重寫父類方法
SubClass.prototype.getSuperValue = function () {
return false;
};
var instance = new SubClass();
alert(instance.getSuperValue()); // false,子類方法覆蓋了父類方法
如果把 SubClass.prototype = new SuperClass() 寫在後面,先前掛上去的方法會全部被丟掉,重寫的父類方法也永遠不會生效。
原型鏈繼承的兩個缺點:一是所有實例共享父類中的屬性(特別是陣列、物件這類參考型別,一個實例改了,其他也跟著變);二是建立子類時無法向父類建構函式傳參。
用 call() 或 apply() 在子類建構時「借」父類建構函式來跑一次, solves 了共享問題,也能傳參數。
function SuperClass(name) {
this.name = name;
}
function SubClass() {
SuperClass.call(this, "RuiLiang"); // 繼承父類並傳入參數
this.age = 29;
}
var instance = new SubClass();
alert(instance.name); // "RuiLiang"
alert(instance.age); // 29
缺點也很明顯:方法都綁在 this 上,無法透過原型復用,每個實例都會產生一份函式。
把兩種做法拼起來:屬性用借用建構函式,方法用原型鏈。這樣既避免共享問題,又能復用方法。
// 父類
function SuperClass(name) {
this.name = name;
this.colors = ["red", "blue", "green"];
}
SuperClass.prototype.sayName = function () {
alert(this.name);
};
// 子類
function SubClass(name, age) {
SuperClass.call(this, name); // 繼承屬性
this.age = age; // 自己的屬性
}
SubClass.prototype = new SuperClass(); // 繼承方法
SubClass.prototype.sayAge = function () {
alert(this.age);
};
// 使用
var instance1 = new SubClass("RuiLiang", 30);
instance1.colors.push("black");
alert(instance1.colors); // red,blue,green,black
instance1.sayName(); // RuiLiang
instance1.sayAge(); // 30
var instance2 = new SubClass("XuZuNan", 26);
alert(instance2.colors); // red,blue,green,彼此互不干擾
注意最後那段程式碼中原本的範例輸出有誤:sayName() 印出的應該是各自的 name("XuZuNan"),因為屬性是在建構函式中個別賦值的。這也正好說明了組合繼承的好處——每個實例擁有自己的屬性副本。
還有幾種常見變形:
Object.create() 建立新物件若使用 ES6 以後的環境,直接用 class 與 extends 即可——它們本質上仍是原型繼承的語法糖,但可讀性與正確性都好得多。