DIV CSS 佈局教程網

JavaScript 的類繼承:Crockford 經典模式解析
編輯:關於JavaScript     

JavaScript Inheritance

Douglas Crockford
www.crockford.com

And you think you're so clever and classless and free
-- John Lennon

JavaScript 是一種沒有類別概念的物件導向語言,它以原型繼承取代類別繼承。對受過 C++、Java 這類傳統物件導向語言訓練的工程師來說,這件事常令人困惑。但其實原型繼承的表達力比類別繼承更強。

先看看兩者的對照:

JavaJavaScript
強型別弱型別
靜態動態
基於類別基於原型
類別函式
建構子函式
方法函式

那麼,為什麼我們在意繼承?主要有兩個原因。

第一是型別的方便。我們希望語言系統能自動完成型別轉換(cast),小規模的型別安全可以靠要求程式明確指定物件參照的型別來取得。這是強型別語言的關鍵,但對 JavaScript 這種弱型別語言毫無意義,其中的物件參照本來就不需要強制轉換。

第二是程式碼 reuse。實作中常會發現大量物件實作了相同的方法。類別讓「集中建立一處定義」成為可能。更常見的情況是:物件之間幾乎相同,只差一小部分方法的增補或修改,這正是類別繼承的用武之地,而原型繼承在這裡甚至更好用。

為了示範,我們先弄幾個小工具(作者稱之為「小甜點」),讓 JavaScript 寫起來像一般的類別語言,接著展示一些類別語言做不到的模式,最後再拆解這些工具的原理。

類別繼承

先建立一個 Parenizor 類別,含 value 的 get/set 方法,以及把值包進括號的 toString 方法:

function Parenizor(value) {
    this.setValue(value);
}
Parenizor.method('setValue', function (value) {
    this.value = value;
    return this;
});
Parenizor.method('getValue', function () {
    return this.value;
});
Parenizor.method('toString', function () {
    return '(' + this.getValue() + ')';
});

語法本身沒什麼特別,但類別的形式很清楚。method 接受方法名與函式,把它掛進類別成為公開方法。

於是使用起來像這樣:

myParenizor = new Parenizor(0);
myString = myParenizor.toString();

如預期,myString 是 "(0)"。

接著建立一個繼承自 Parenizor 的新類別,行為幾乎相同,只差 toString 在值為零或空時輸出 "-0-":

function ZParenizor(value) {
    this.setValue(value);
}
ZParenizor.inherits(Parenizor);
ZParenizor.method("toString", function () {
    if (this.getValue()) {
        return this.uber('toString');
    }
    return "-0-";
});

inherits 的作用等同 Java 的 extends,而 uber 等同 super,用來讓子類別呼叫父類別的同名方法(改名是為了避開保留字)。

myZParenizor = new ZParenizor(0);
myString = myZParenizor.toString();

這回 myString 是 "-0-"。JavaScript 沒有類別,但我們能用程式達成同樣效果。

多重繼承

透過操作函式的 prototype 物件,也能實作多重繼承。混血型的多重繼承不易處理,而且容易爆發命名衝突。JavaScript 當然做得到,但這裡採用一種比較規範的形式,稱為瑞士式繼承(Swiss Inheritance)。

假設有個 NumberValue 類別,其 setValue 會檢查值是否為指定範圍內的數字,必要時丟出例外。我們只想要它的 setValue 與 setRange,不要 toString,就可以寫成:

ZParenizor.swiss(NumberValue, 'setValue', 'setRange');

這樣只會補上指定的方法,其他一概不動。

寄生繼承

另一種寫 ZParenizor 的方式:不去繼承 Parenizor,而是在建構子裡呼叫 Parenizor 建構子,修改結果後再回傳。這種做法加上的是特權方法而非公開方法。

function ZParenizor2(value) {
    var self = new Parenizor(value);
    self.toString = function () {
        if (this.getValue()) {
            return this.uber('toString');
        }
        return "-0-"
    };
    return self;
}

類別繼承表達的是「是……」的關係,寄生繼承表達的則是「原本是……而現在是……」。建構子在物件構造中扮演重要角色。值得注意的是,uber(替代 super 關鍵字)對特權方法依然有效。

類別擴充

JavaScript 的動態性讓我們能隨時為既有類別增補或替換方法,任何時刻都能擴充。這和繼承無關,因此稱之為「類別擴充」,以免與 Java 的 extends(也叫擴充,但完全是另一回事)混淆。

物件擴充

在靜態物件導向語言裡,若希望某個物件與另一個物件不同,就必須建立新的類別。但在 JavaScript 中,你可以直接替單一物件加方法而不必新增類別。這力量很大,因為它能讓你寫最少的類別,而且類別本身也寫得更單純。把 JavaScript 物件想成雜湊表就好:任何時候都能塞進新值,而這個值若是函式,就成了一個方法。

所以前面那個例子,其實完全不需要 ZParenizor 類別,只要直接改 myParenizor 這個實例就行:

myParenizor = new Parenizor(0);
myParenizor.toString = function () {
    if (this.getValue()) {
        return this.uber('toString');
    }
    return "-0-";
};
myString = myParenizor.toString();

我們替 myParenizor 加了 toString,完全沒用到繼承。因為語言沒有型別,個別實例可以被獨立演化。

小甜點

要讓上述範例跑起來,作者寫了四個輔助方法。第一個是 method,用來把實例方法加進類別:

Function.prototype.method = function (name, func) {
    this.prototype[name] = func;
    return this;
};

它掛在 Function.prototype 上,因此透過類別擴充,所有函式都能使用。它接受名稱與函式兩個參數,並回傳 this。作者習慣讓沒有回傳值的方法回傳 this,如此一來便能串接成鏈式呼叫。

再來是 inherits,用來宣告某類別繼承自另一類別。它必須在兩個類別都定義完之後才定義,但要早於任何方法繼承的呼叫:

Function.method('inherits', function (parent) {
    var d = 0, p = (this.prototype = new parent());
    this.method('uber', function uber(name) {
        var f, r, t = d, v = parent.prototype;
        if (t) {
            while (t) {
                v = v.constructor.prototype;
                t -= 1;
            }
            f = v[name];
        } else {
            f = p[name];
            if (f == this[name]) {
                f = v[name];
            }
        }
        d += 1;
        r = f.apply(this, Array.prototype.slice.apply(arguments, [1]));
        d -= 1;
        return r;
    });
    return this;
});

這裡擴充了 Function 類別:把父類別的實例作為新的 prototype,同時修正 constructor 欄位,並加入 uber 方法。

uber 會先在自己的 prototype 中找方法,這是寄生繼承或類別擴充的情況;若屬類別繼承,則要往上找到 parent 的 prototype。return 那行呼叫函式的 apply,明確指定 this 並帶入參數。參數可從 arguments 取得,只可惜 arguments 不是真正的陣列,所以又得借 apply 來呼叫陣列的 slice。

最後是 swiss:

Function.method('swiss', function (parent) {
    for (var i = 1; i < arguments.length; i += 1) {
        var name = arguments[i];
        this.prototype[name] = parent.prototype[name];
    }
    return this;
});

它逐一走過每個參數,把 parent 原型上的對應成員複製到新類別的 prototype 裡。

總結

JavaScript 可以像類別語言那樣使用,但它同時具備一種獨特的表現層次。我們已經看過類別繼承、瑞士繼承、寄生繼承、類別擴充與物件擴充——這一系列程式碼 reuse 的模式,全都來自這個一直被認為「很小、很簡單」的語言。

類別物件是「硬的」:想給硬物件添成員,唯一的辦法是建立新類別。JavaScript 的物件是「軟的」:想加成員,直接賦值即可。

正因為 JavaScript 的類別如此靈活,你可能會想嘗試更複雜的繼承結構。但深度繼承並不合適,淺繼承反而更有效、更好表達。

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