JS 一共有六種繼承模式:原型鏈、借用建構函式、組合繼承、原型式繼承、寄生式繼承與寄生組合式繼承。為了把它們記牢,不妨借一個比喻——女媧造人。
女媧一個一個捏人太慢,於是發明了機器(函式):告訴它要造什麼樣的人,它就能量產。這是工廠模式,但每個函式都長得差不多,重複的程式碼很多。
接著出現封裝的想法:眼睛、鼻子先做好備用,機器要什麼就拿來裝,這就是建構函式。
但問題還在:若每個人都需要「跑」的能力,難不成要一一套裝?把函式定義在建構函式外部(全域作用域)確實可以共用,可是能力一多,全域函式就會爆炸。於是 prototype 登場——每個函式都有一個 prototype 屬性,指向原型物件;原型物件上放著所有實例共享的屬性與方法,並有一個 constructor 指回該函式。
用女媧的視角看:每台造人機器都有唯一一個模具(原型物件),機器上貼著 prototype 標籤指向模具,模具上又有 constructor 標示「由這台機器生產」。要改這類人的共通特徵,改模具就好。
// 1. 造機器 A
function jqA(){}; // 有 prototype 屬性,指向模具(原型物件)
// 2. 造模具
jqA.prototype = {
constructor: jqA, // 貼上標籤:由 A 機器生產
name: 'lily',
skin: 'white',
run: function(){
alert(this.name + ' run');
}
};
// 3. 造兩個這類型的人
var person1 = new jqA();
var person2 = new jqA();
person1 與 person2 都有一個 [[Prototype]],表示經過模具 A 處理,指向 A 的模具。
問題來了:這樣造出來的人一模一樣。所以機器在套用模具的同時,還要能依指令做出差異——「這個藍眼睛、那個胖一點」。這個差異化能力由建構函式負責,兩者合用就是組合使用建構函式與原型模式。
女媧嫌一邊顧機器一邊顧模具太麻煩,乾脆把模具嵌進機器裡:
function Person(name, skill, country) {
this.name = name;
this.skill = skill;
this.country = country;
if (typeof this.sayCountry != "undefined") {
Person.prototype.sayCountry = function () {
alert(this.country);
};
}
}
var friend = new Person('張飛', '咆哮', '蜀國');
friend.sayCountry();
還有寄生建構函式模式:機器內部再放一台小機器負責生產,再把成品交回外部機器對外提供。實務上較少用到。
女媧要造另一批人 B,希望他們擁有先前那批人的特徵。做法是讓 B 的模具等於「一個由 A 造出來的實例」,這個實例自然會過濾到 A 的模具。
// 父函式(機器 A)
function SuperType(){
this.property = true;
}
// 在 SuperType 的原型(模具 A)上加方法
SuperType.prototype.getSuperValue = function(){
return this.property;
};
// 子函式(機器 B)
function SubType(){
this.subproperty = false;
}
// 繼承 SuperType —— 這就是原型鏈
SubType.prototype = new SuperType();
SubType.prototype.getSubValue = function(){
return this.subproperty;
};
var instance = new SubType();
alert(instance.getSuperValue()); // true
問題:原型上的引用型別值會被所有實例共享,改一個會影響全部。
把模具 A 的內容直接寫進機器 B 裡,讓 B 生產時把 A 的屬性與方法一併實例化,且可以透過參數控制差異。
function SuperType(){
this.colors = ['red', 'blue', 'green'];
}
function SubType(){
// 繼承 SuperType
SuperType.call(this);
}
var instance1 = new SubType();
instance1.colors.push('black');
alert(instance1.colors); // red,blue,green,black
var instance2 = new SubType();
alert(instance2.colors); // red,blue,green —— 互不影響
function SuperType(name){
this.name = name;
}
function SubType(){
// 繼承並傳遞參數
SuperType.call(this, '趙雲');
this.age = 29; // 實例屬性
}
var instance = new SubType();
alert(instance.name); // 趙雲
alert(instance.age); // 29
為了避免父類建構函式覆寫子類的屬性,順序很重要:先呼叫父類建構函式,再加上子類自己定義的屬性。
問題:方法只能在建構函式內部定義,無法共用,等於浪費了模具——有打火機了還要鑽木取火。
把兩種技術合起來:用原型鏈繼承原型上的屬性與方法,用借用建構函式繼承實例屬性。原型鏈的問題是引用屬性共享,借用建構函式的問題是方法不能複用,兩者互補剛好完美。
function SuperType(name){
this.name = name;
this.colors = ['red', 'blue', 'green'];
}
SuperType.prototype.sayName = function(){
alert(this.name);
};
function SubType(name, age){
// 繼承屬性
SuperType.call(this, name);
this.age = age;
}
// 繼承方法
SubType.prototype = new SuperType();
SubType.prototype.sayAge = function(){
alert(this.age);
};
var instance1 = new SubType('zhaoyun', 29);
instance1.colors.push('black');
alert(instance1.colors); // red,blue,green,black
instance1.sayName(); // zhaoyun
instance1.sayAge(); // 29
var instance2 = new SubType('諸葛瑾', 25);
alert(instance2.colors); // red,blue,green
instance2.sayName(); // 諸葛瑾
instance2.sayAge(); // 25
剩下兩種——原型式繼承(以 Object.create 為核心,讓物件直接「繼承」另一個物件)與寄生組合式繼承(用一個中轉函式暫存原型,避免多呼叫一次父類建構函式)——都是在組合繼承的基礎上做優化,思路相同:既要方法複用,也要屬性隔離。理解這條主線,六種模式就不必死背了。