JavaScript 中,物件型別的 prototype 屬性會回傳該型別原型的參照。要理解這句話,得先釐清「型別(Type)」與「原型(prototype)」這兩個概念。
類(Class)與實例(Instance)之間是「建立」關係:類是特徵的模型化,物件是類特徵的具體化,也就是說類就是物件的一個型別。以 p1、p2 為例,它們的型別都是 Point,可用 instanceof 驗證:
p1 instanceof Point p2 instanceof Point
但 Point 並不是唯一型別——p1、p2 都是物件,所以 Object 也是它們的型別。Object 比 Point 更為泛化,兩者之間的關係稱為「繼承」,這是物件之間泛化關係的特例,也是物件導向不可或缺的基礎關係。
在物件導向領域裡,除了「實例—型別」,JavaScript 中還存在一組更重要的抽象關係:「型別—原型」。它是更高層次的抽象,恰好與前者構成一條三層鏈。
現實生活中我們常說某樣東西是以另一樣為原型創作的,兩者可以同類也可以不同類。成語「照貓畫虎」裡,貓就是原型,虎是型別,用 JavaScript 表達就是 虎.prototype = 某隻貓 或 虎.prototype = new 貓()。相較於繼承描述血緣式的衍生關係、介面描述功能上的共同特徵,原型描述的則是事物之間的「相似性」,涵蓋面更廣。
值得注意的限制是:一個型別在任一時刻只能有一個原型(而一個實例可以同時屬於多個型別)。對 JavaScript 而言這有兩層含義:其一,每個型別有且僅有一個 prototype,預設是一個 Object 物件(不是 Object 型別);其二,該物件所屬的型別必須構成完整的原型鏈。
有意思的是,JavaScript 並未規定原型的型別,因此「物件—型別—原型」之間可能形成環狀或其他拓撲結構,衍生出五花八門的用法。
JavaScript 為每個型別都提供了 prototype 屬性,把它指向某個物件,該物件就成為這個型別的原型,由這個型別建立的所有物件都會具備原型的特性。而且原型是動態的,增減屬性會即時反映到所有實例上:
<script>
function Point(x, y) {
this.x = x;
this.y = y;
}
var p1 = new Point(1, 2);
var p2 = new Point(3, 4);
Point.prototype.z = 0; // 動態為原型新增屬性
alert(p1.z);
alert(p2.z); // 同時作用於所有 Point 物件
</script>
技巧一:設定預設值。若物件自身有與原型同名的屬性,自身屬性會「遮蔽」原型屬性,但原型屬性並未消失;用 delete 移除自身屬性後,原型屬性會重新可見。
<script>
function Point(x, y) {
if (x) this.x = x;
if (y) this.y = y;
}
Point.prototype.x = 0;
Point.prototype.y = 0;
var p1 = new Point; // (0, 0)
var p2 = new Point(1, 2); // (1, 2)
</script>
接著 delete p2.x; delete p2.y; 就能把 p2 恢復成 (0, 0)。把這個特性推到極致,還能寫出一鍵重置:
<script>
function classA() {
this.a = 100;
this.b = 200;
this.c = 300;
this.reset = function() {
for (var each in this) {
delete this[each];
}
}
}
classA.prototype = new classA();
var a = new classA();
alert(a.a);
a.a *= 2; a.b *= 2; a.c *= 2;
alert(a.a); alert(a.b); alert(a.c);
a.reset(); // 回復預設值
alert(a.a); alert(a.b); alert(a.c);
</script>
技巧二:製作唯讀副本。直接回傳私有成員,呼叫方一旦改寫就無法復原:
this.getFirstPoint = function() {
return m_firstPoint;
}
// ...
var lp = line1.getFirstPoint();
lp.x = 100; // 不小心改寫,原始值被破壞且不可恢復
alert(line1.getFirstPoint().x);
alert(line1.length); // 連 length 也跟著變了
解法是回傳一個以該物件為原型的空建構式實例:
this.getFirstPoint = function() {
function GETTER() {};
GETTER.prototype = m_firstPoint;
return new GETTER();
}
如此一來,改寫副本只會在自己身上建立同名屬性,原始私有成員安然無恙;若要恢復,delete 掉副本屬性即可。這個模式在 Polygon 這類集合物件上同樣適用:
<script>
function Polygon() {
var m_points = [];
m_points = Array.apply(m_points, arguments);
function GETTER() {};
GETTER.prototype = m_points[0];
this.firstPoint = new GETTER();
this.length = {
valueOf: function() { return m_points.length },
toString: function() { return m_points.length }
}
this.add = function() {
m_points.push.apply(m_points, arguments);
}
this.getPoint = function(idx) {
return m_points[idx];
}
this.setPoint = function(idx, point) {
if (m_points[idx] == null) {
m_points[idx] = point;
} else {
m_points[idx].x = point.x;
m_points[idx].y = point.y;
}
}
}
var p = new Polygon({x:1, y:2}, {x:2, y:4}, {x:2, y:6});
alert(p.length);
alert(p.firstPoint.x);
p.firstPoint.x = 100; // 誤寫副本
alert(p.getPoint(0).x); // 私有成員不受影響
delete p.firstPoint.x; // 恢復
alert(p.firstPoint.x);
p.setPoint(0, {x:3, y:4}); // 透過 setter 改動私有成員
alert(p.firstPoint.x); // getter 的值同步改變
</script>
技巧三:快速大量建立副本。用一個物件當原型來批量產生新物件,正是 prototype pattern 的本質,效能遠優於逐屬性 copy:
<script>
var p1 = new Point(1, 2);
var points = [];
var PointPrototype = function() {};
PointPrototype.prototype = p1;
for (var i = 0; i < 10000; i++) {
points[i] = new PointPrototype();
// 因為 PointPrototype 的建構式是空函式,建立成本遠低於複製 p1
}
</script>
prototype 的行為近似 C++ 的靜態域:掛在上面的屬性由該型別的所有實例共享,但這種共享是唯讀的——實例只能用同名屬性遮蔽,無法改動原型本身。
因此屬性讀取的規則是:先查自身屬性表,找到就回傳;找不到則轉往 prototype 域;若仍未命中,由於 prototype 可以參照任意物件,引擎會遞迴沿著原型鏈往上找,直到原型指向自身或出現循環為止。
prototype 的真正價值在於:能以一個物件為原型,安全地建立大量實例。它常被拿來模擬繼承,但模擬繼承絕不是它的核心用途——即使沒有繼承,prototype 機制本身依然非常有用。
局限也很明確:原型域上的屬性屬於參照拷貝而非值拷貝,這會帶來副作用。改動原型上參照型別屬性的內部狀態,會徹底影響該型別的每一個實例:
<script>
function ClassA() {
this.a = [];
}
function ClassB() {
this.b = function() {};
}
ClassB.prototype = new ClassA();
var objB1 = new ClassB();
var objB2 = new ClassB();
objB1.a.push(1, 2, 3);
alert(objB2.a); // 所有 B 的實例中的 a 全都變了!
</script>
有時這正是我們想要的(例如統一調整某類物件的預設值),但在實作繼承時往往並非所願,這也是設計類別層級時必須留意的地方。
Java 中所有物件都繼承自 java.lang.Object,實作 Cloneable 介面即可支援 clone,否則拋出例外。JavaScript similarly 讓所有物件繼承自 Object,只是 Object 並未提供 clone,因此必須自行擴充。
由於 var b = a 只是讓兩個變數指向同一個物件,真正複製必須透過 new。做法是內部定義一個空建構式 CloneModel,並把它的原型指向要複製的來源物件,如此建立的新物件在行為上等同於來源。但此時所有值仍舊指向父物件,而 Prototype Pattern 要求複製後的內部值彼此獨立,因此再補上一層 objClone[v] = objClone[v];,透過賦值把父物件的值以遮蔽方式落地到自己的記憶體空間,複製才算真正完成。