DIV CSS 佈局教程網

用原型鏈實作 JavaScript 物件系統與多級繼承
編輯:關於JavaScript     

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 預設指向建立它的建構函數,而建構函數原型的 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 的底層行為,也是除錯時判斷屬性來源、方法查找路徑的基礎。

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