John Resig 寫過一篇很有名的文章,示範如何在 JavaScript 裡做出類似其他語言的「繼承」,靈感來自 base2 與 Prototype.js。他用了幾個相當巧妙的手法來實作 _super 方法,後來也在《Secrets of a JavaScript Ninja》一書中介紹過(書中的做法略有不同,是把方法掛在 Object 上而非全域變數)。以下逐段拆解原始程式碼——作者註明翻譯中摻入了個人理解,若有錯誤歡迎指正。
(function(){
var initializing = false, fnTest = /xyz/.test(function(){xyz;}) ? /\b_super\b/ : /.*/;
this.Class = function(){};
Class.extend = function(prop) {
var _super = this.prototype;
initializing = true;
var prototype = new this();
initializing = false;
for (var name in prop) {
prototype[name] = typeof prop[name] == "function" &&
typeof _super[name] == "function" && fnTest.test(prop[name]) ?
(function(name, fn){
return function() {
var tmp = this._super;
this._super = _super[name];
var ret = fn.apply(this, arguments);
this._super = tmp;
return ret;
};
})(name, prop[name]) :
prop[name];
}
function Class() {
if ( !initializing && this.init )
this.init.apply(this, arguments);
}
Class.prototype = prototype;
Class.constructor = Class;
Class.extend = arguments.callee;
return Class;
};
})();
(function(){ // ... })();
自執行的匿名函式,替整段程式碼隔出一個獨立作用域,不污染全域。
var initializing = false
這個 boolean 用來判斷 Class 函式「正在被怎麼呼叫」。建立實例時設為 false,於是 init 會自動執行;只需要拿原型來做繼承時設為 true,於是 new this() 不會觸發 init。少了這個開關,每次建立原型都會誤跑一次初始化。
fnTest = /xyz/.test(function(){xyz;}) ? /\b_super\b/ : /.*/;
這行用了所謂的「函式反編譯」或「函式序列化」技巧——把函式轉成字串後再檢查內容。它先塞一個內容為 xyz 的匿名函式進去,轉字串後搜尋 xyz:瀏覽器若支援序列化,就會找到,於是 fnTest 變成 /\b_super\b/,只用來偵測方法裡有沒有呼叫 _super;不支援時退回 /.*/,永遠為真。
這個偵測的目的,是決定「要不要為這個方法包一層特殊處理」。若不偵測,父類與子類同名的方法會直接互相覆蓋,_super 也就無從呼叫。不支援序列化的瀏覽器會永遠走特殊分支,效能略差,而且無法在 _super 裡再嵌套使用,但功能上仍能正常運作。
this.Class = function(){};
建立一個空的頂層建構函式掛到全域(this 指 window),後續所有類都從它 extend 而來。
Class.extend = function(prop) { // ... }
var _super = this.prototype;
把目前的原型存進 _super,這樣在子類裡就能回頭存取父類方法。變數取名 _super 而非 super,是因為後者是保留字。
initializing = true; var prototype = new this(); initializing = false;
透過 new this() 拿到一份「繼承鏈正確」的實例當原型,但靠 initializing 讓 init 不執行。完成後立刻把旗標設回 false,好讓真正建立實例時能正常初始化。
for (var name in prop) { // ... }
把傳進來的 prop 逐項掛到 prototype 上,其中對 _super 相關的方法要特別處理。
if (typeof prop[name] == "function" &&
typeof _super[name] == "function" &&
fnTest.test(prop[name])) {
prototype[name] = (function(name, fn){
return function() {
// special handling for _super
};
})(name, prop[name]);
} else {
// 直接複製屬性
prototype[name] = prop[name];
}
只有「子類有同名方法、父類也有同名方法、且子類方法裡用到了 _super」這三個條件同時成立,才需要包裝。這裡那層自執行的匿名函式是必要的閉包:若直接在迴圈裡回傳函式,name 與 fn 的參考會指向迴圈的最後一輪,所有方法都會指向同一個。
// special handling for _super var tmp = this._super; this._super = _super[name]; var ret = fn.apply(this, arguments); this._super = tmp; return ret;
先把既有的 this._super 暫存到 tmp(避免巢狀繼承時互相覆寫),再把父類的同名方法掛上去,然後用 apply 執行子類方法——此時方法內的 this._super() 就指向父類實作,而 this 依然是當前物件。最後還原 _super 並回傳結果。
var Foo = Class.extend({
qux: function() { return "Foo.qux"; }
});
var Bar = Foo.extend({
qux: function() { return "Bar.qux, " + this._super(); }
});
執行 Foo.extend 之後,Bar 原型上的 qux 實際長這樣:
Bar.prototype.qux = function () {
var tmp = this._super;
this._super = Foo.prototype.qux;
var ret = (function() {
return "Bar.qux, " + this._super();
}).apply(this, arguments);
this._super = tmp;
return ret;
}
function Class() {
if ( !initializing && this.init )
this.init.apply(this, arguments);
}
這個區域的 Class 才是每個類別真正的建構函式。被 new 之後,若存在 init 就自動呼叫,而呼叫與否由 initializing 決定。
Class.prototype = prototype; Class.constructor = Class; Class.extend = arguments.callee; return Class;
prototype 是從父類原型混出來的成果;因為整個原型被替換掉,得把 constructor 補回去,實例的建構行為才正常;最後把 extend 指標回自己,讓每個類別都能繼續被繼承。
這裡的 arguments.callee 有個更乾淨的替代寫法——把 extend 命名,然後直接指名:
Class.extend = function extend(prop) { /* ... */ };
// 內部即可寫成
Class.extend = extend;
值得一提的是,這套寫法依賴 arguments.callee,在 ES5 嚴格模式下已被禁用。今天要寫 class 繼承,直接用 class B extends A 與 super.method() 就是語言層級的原生支援;但讀懂這份程式碼,你會更明白 super 背後到底做了什麼——本質上就是「暫存、替換 this 的查找起點、執行、還原」這四步。