上一篇聊了《JavaScript 原型繼承之基礎機制》,這一篇具體說說構造函數繼承的幾種實現方式。
先準備兩個構造函數。一個描述人類:
function People(){
this.race = '愚蠢的人類';
}
一個描述黃種人:
function Yellow(name, skin){
this.name = name;
this.skin = skin;
}
要讓 Yellow 繼承 People,JavaScript 裡有多種模擬方式,下面逐一來看。
思路很直白:把描述抽象類的構造函數當作普通函數來調用,實現「偽繼承」。
function Yellow(name, skin) {
this._extend = People;
this._extend();
delete this._extend; // 刪除對 People 的引用
this.name = name;
this.skin = skin;
}
// 實例化 yellow1
var yellow1 = new Yellow('小明', '黃皮膚');
console.log(yellow1.name); // 小明
console.log(yellow1.race); // 愚蠢的人類
這段代碼為 Yellow 添加了一個私有方法 _extend。由於函數本身只是以引用的形式存在,執行時會以 Yellow 的 this 作為上下文調用 People,於是 People 裡給 this 掛的屬性就都落到了 yellow1 身上。
注意順序:Yellow 自身的屬性和方法,必須在這個過程結束、清空對外部方法的引用之後再定義,否則會被覆蓋。
這種方式有個額外好處:可以實現多重繼承,多冒充幾個構造函數就行了。
用 call / apply 實現繼承可能更為簡潔,不需要任何繁瑣的中間步驟:
function Yellow(name, skin) {
People.apply(this, arguments);
this.name = name;
this.skin = skin;
}
// 實例化 yellow2
var yellow2 = new Yellow('大衛', '黑皮膚');
console.log(yellow2.name); // 大衛
console.log(yellow2.race); // 愚蠢的人類
這裡為 apply 傳入 arguments 數組,也可以顯式構造一個數組傳進去。本質上它與對象冒充是同一回事,只是用 apply 更乾淨地完成了「借用構造函數」這一步。
但要清楚它的局限:這種方式只繼承構造函數裡的實例屬性,完全不涉及原型。父類掛在 prototype 上的方法一個都拿不到。
第一種原型繼承方法是把子類的原型指向父類的某個實例:
Yellow.prototype = new People();
Yellow.prototype.constructor = Yellow; // 初始的 prototype 被完全清空,所以最好將 constructor 重置
var yellow3 = new Yellow('小王', '黃皮膚');
console.log(yellow3.race); // 愚蠢的人類
反過來理解會更清楚:yellow3 實例本身找不到 race 屬性,於是沿原型鏈往上查,而它原型上的 race 恰好就是 People 那個實例的 race。
如果父類的屬性本身就寫在原型上,那就無需實例化,直接把兩個 prototype 指向同一個對象即可:
function People(){};
People.prototype.race = '愚蠢的人類';
Yellow.prototype = People.prototype;
Yellow.prototype.constructor = Yellow;
這樣做不涉及實例化,只是指針的改變,看起來很「環保」。但由於引用類型的緣故,Yellow 和 People 指向了同一個原型對象——也就是說,對 Yellow.prototype.constructor 的修改實際上破壞了 People 的原型。往 Yellow.prototype 上加任何東西,People 也會跟著變。這顯然不是我們想要的。
既然如此,可以用一個空函數作為中繼,繞過對父類原型的直接引用:
var F = function(){};
F.prototype = People.prototype;
Yellow.prototype = new F();
Yellow.prototype.constructor = Yellow;
F 的原型指向 People.prototype,但 Yellow 的原型是一個全新的 F 實例。查找屬性時,鏈路是「yellow3 → F 實例 → People.prototype」,能拿到父類原型上的一切;而往 Yellow.prototype 上添加新成員時,寫入的是那個 F 實例,不會污染 People.prototype。
這就是後來的經典繼承(也就是所謂「原型式繼承 + 構造函數借用」組合)的核心骨架:
function inherit(Sub, Super){
var F = function(){};
F.prototype = Super.prototype;
Sub.prototype = new F();
Sub.prototype.constructor = Sub;
}
function Yellow(name, skin){
People.call(this); // 借用構造函數,繼承實例屬性
this.name = name;
this.skin = skin;
}
inherit(Yellow, People); // 建立原型鏈,繼承原型方法
兩步組合起來,實例屬性和原型方法就都照顧到了,同時避免了引用共享的副作用。實戰中再加一層 Object.create 的判斷,就是我們今天看到的標準做法。