DIV CSS 佈局教程網

JavaScript 物件導向中神奇的 prototype
編輯:關於JavaScript     

一、什麼是 prototype

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 並未規定原型的型別,因此「物件—型別—原型」之間可能形成環狀或其他拓撲結構,衍生出五花八門的用法。

二、prototype 的實用技巧

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 的實質

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>

有時這正是我們想要的(例如統一調整某類物件的預設值),但在實作繼承時往往並非所願,這也是設計類別層級時必須留意的地方。

五、延伸:自己實作 Clone

Java 中所有物件都繼承自 java.lang.Object,實作 Cloneable 介面即可支援 clone,否則拋出例外。JavaScript similarly 讓所有物件繼承自 Object,只是 Object 並未提供 clone,因此必須自行擴充。

由於 var b = a 只是讓兩個變數指向同一個物件,真正複製必須透過 new。做法是內部定義一個空建構式 CloneModel,並把它的原型指向要複製的來源物件,如此建立的新物件在行為上等同於來源。但此時所有值仍舊指向父物件,而 Prototype Pattern 要求複製後的內部值彼此獨立,因此再補上一層 objClone[v] = objClone[v];,透過賦值把父物件的值以遮蔽方式落地到自己的記憶體空間,複製才算真正完成。

XML學習教程| jQuery入門知識| AJAX入門| Dreamweaver教程| Fireworks入門知識| SEO技巧| SEO優化集錦|
Copyright © DIV+CSS佈局教程網 All Rights Reserved