JavaScript 沒有 class 關鍵字,只有建構函數與原型。理解原型鏈的運作方式,就能自己搭出一套可讀、可維護的繼承機制。
物件本身沒有原型,建構函數才有原型。若建構函數 A 有一個原型物件 P,那麼由 A 建立的所有實例都會鏈接到 P。實例讀取屬性時,先找自己,找不到就沿 __proto__ 上溯到原型。
var flower = function(){ this.name = "nokia"; };
var flower2 = function(){ this.age = 22; };
flower2.prototype = new flower(); // 建立原型鏈
var obj = new flower2();
alert(obj.name); // "nokia" —— 從父類繼承
alert(obj.age); // 22
實例的 constructor 預設指向建立它的建構函數,而建構函數原型的 constructor 指向建構函數本身。但一旦替換了 prototype,這個關聯就斷了。
function flower(){}
function flower2(){}
flower2.prototype = new flower();
var obj1 = new flower();
var obj2 = new flower2();
alert(obj1.constructor == obj2.constructor); // true —— 出問題了
兩者都由不同建構函數產生,constructor 卻相同,是因為 flower2.prototype 被換成了 flower 的實例,而該實例的 constructor 自然指向 flower。
解法是在替換原型後補回 constructor:
flower2.prototype = new flower(); flower2.prototype.constructor = flower2;
或在建構時顯式指定:
function flower2(){
this.constructor = arguments.callee;
}
flower2.prototype = new flower();
純原型繼承有個明顯缺陷:沒有內建機制呼叫父類的同名方法。解法是用靜態變量記錄繼承深度,讓 parent() 知道該往上一層還是上兩層找。
var Class = {
create: function()
{
var _class = function(){ this.init.apply(this, arguments); };
_class.prototype.init = Function.prototype.init;
try { return _class; } finally { _class = null; }
}
};
// 預設建構函數
Function.prototype.init = function(){};
// 方法擴充
Function.prototype.extend = function(list)
{
for (var i in list) this.prototype[i] = list[i];
return this;
};
// 多級繼承
Function.prototype.inherits = function(parent)
{
var _depth = 0; // 繼承深度
this.extend(new parent()); // 移植方法屬性
this.prototype.init = Function.prototype.init;
this.parent = parent; // 靜態父類
this.prototype.parent = function(name)
{
if (!name) name = 'init';
var _parent = parent;
if (_depth) { // 已在父類中,繼續向上找
for (var i = 0; i < _depth; i++) _parent = _parent.parent;
}
_depth++;
try {
return _parent.prototype[name].apply(this, Array.prototype.slice.apply(arguments, [1]));
} catch(e) {
throw(e);
} finally {
_depth--; // 恢復深度
}
};
return this;
};
// 建立名為 class1 的建構函數
var class1 = Class.create().extend({
b: function(){ alert('class'); alert(this.c); },
c: 100
});
var s = new class1();
s.b(); // "class", 100
// 繼承並呼叫父類方法
var test = Class.create().inherits(class1).extend({
b: function(){
alert('test');
this.parent('b'); // 呼叫父類的 b
},
c: 110
});
直接擴充 Function.prototype 是這段程式碼最大的問題——它污染了所有函數,可能與第三方庫衝突,也會讓 for-in 遍歷多出意料之外的鍵。以今天的標準來看,這是不推薦的做法。
同樣地,arguments.callee 在嚴格模式下已禁用。ES6 之後,class 語法、extends 與 super 提供了語法糖,底層仍是原型鏈,但可讀性與安全性都大幅改善:
class Flower {
constructor(){ this.name = "nokia"; }
greet(){ return "I am " + this.name; }
}
class Rose extends Flower {
constructor(){
super();
this.age = 22;
}
greet(){ return super.greet() + ", age " + this.age; }
}
理解原型鏈的機制仍有價值——它解釋了 ES6 class 的底層行為,也是除錯時判斷屬性來源、方法查找路徑的基礎。