DIV CSS 佈局教程網

JavaScript 模擬類機制與私有變量:從 new Class 說起
編輯:JavaScript綜合知識     

用過一些 JS 框架的人大概見過這種代碼:

var MyClass = new Class({
    initialize: function (param) {
        this.param = param;
    },
    func1: function () { /* ... */ }
});

var myObj = new MyClass(param);
myObj.func1();

相比原生的寫法,這套「new Class + initialize」的形式顯得更清晰自然,在它的基礎上實現繼承也比較方便。它是怎麼做出來的?

原生寫法對照

眾所周知,把一個函數當構造器,配合 new 就能創建對象。上面那段可以樸素地寫成:

function MyClass(param) {
    this.param = param;
    this.func1 = function () { /* ... */ };
}

var myObj = new MyClass(param);
myObj.func1();

功能完全等價,但這裡有個隱性問題:方法被掛在每個實例上,而不是共享的原型上。實例一多,內存就被同一份函數代碼重複佔用。改寫成原型掛載更合理:

function MyClass(param) {
    this.param = param;
}
MyClass.prototype.func1 = function () { /* ... */ };

大型類庫裡,混在一起的構造函數、方法、屬性會越來越難辨認。這正是 new Class 這種「聲明式」寫法想解決的問題。

推演 new Class 的實現

先看約束條件:既然要寫 new MyClass(),MyClass 必須是一個函數;而 new Class(...) 必須返回一個函數對象;從字面看,initialize 是當構造函數用的,所以返回的那個函數內部必須調用 initialize 來初始化。基於這三點:

function Class(argu) {
    return function () {
        // 沒有 initialize 就用空函數兜底
        var init = argu['initialize'] || function () {};

        // 把配置裡的所有成員掛到實例上
        for (var p in argu) {
            this[p] = argu[p];
        }

        // 用當前函數的 this 調用 initialize
        init.apply(this, arguments);
    };
}

關鍵是 init.apply(this, arguments) 這一句,涉及兩個指代:一個是 this,它原本是 initialize 自己的 this,現在被替換成返回的那個匿名函數的 this——而這個匿名函數正是 new Class 造出來的構造器;另一個是 arguments,它是匿名函數的參數,也就是 new MyClass(param) 裡的 param。

this 的轉換確實有點繞。有沒有更直白的辦法?有——直接返回 initialize 本身,把其他成員掛到它的 prototype 上:

function Class(argu) {
    var obj = argu['initialize'] || function () {};

    for (var p in argu) {
        obj.prototype[p] = argu[p];   // 注意這裡用的是 prototype
    }

    return obj;                       // 本質上仍然返回一個函數
}

清爽多了。這樣就完成了一個簡陋但可用的類機制:構造函數、方法、屬性都能聲明,而且方法掛在原型上共享。

怎麼實現私有變量

但這些成員顯然都是公有的。JavaScript 實現私有靠閉包,而 new Class({...}) 這種「傳字面量對象」的寫法很難自然形成閉包。要繞過去,可以借兩個工具:eval() 和函數對象的 toString()——後者能取出函數的源碼字符串。

function Class(argu) {
    var _ = argu['private'] || {};

    // 把 initialize 的源碼 eval 出來,形成一個獨立作用域
    eval('var obj = ' + (argu['initialize'] || function () {}).toString());

    for (var p in argu) {
        if (p == 'initialize' || p == 'private') continue;

        if (typeof argu[p] == 'function') {
            // 方法也 eval,讓它能訪問到私有變量 _
            eval('obj.prototype[p] = ' + argu[p].toString());
        } else {
            obj.prototype[p] = argu[p];
        }
    }
    return obj;
}

通過 toString() 提取函數代碼、再用 eval 執行,就能構造出一個有效的閉包作用域,私有機制由此成立:

var Person = new Class({
    private: {
        height: 160,
        weight: 50
    },
    initialize: function (name, height, weight) {
        this.name = name;
        _.height = height || _.height;
        _.weight = weight || _.weight;
    },
    show: function () {
        alert('Name:' + this.name + '/height:' + _.height + '/weight:' + _.weight);
    }
});

var my = new Person("Zh");
my.show();

私有成員放在 private 裡,方法內部通過 _ 訪問,外部則完全看不到。

為什麼不建議這樣做

性能代價高昂。相比常規實現,這套 eval 方案大約要多花四倍時間。在大型類庫的構建上,這是不可容忍的。

eval 帶來安全與調試問題。eval 執行的代碼無法被靜態分析、無法被大多數編輯器跟蹤、堆棧信息也變得難讀。對待外部輸入時更有注入風險。

小項目完全不需要它。下面的原生寫法更簡單直接,也同樣能實現私有:

function MyClass(param) {
    var privateVar = ...;          // 閉包私有

    this.param = param;
    this.func = function () {
        alert(privateVar);
    };
}

今天的答案

ES6 的 class 已經把「聲明式類」變成語言原生特性,而私有成員也有了標準方案:

class MyClass {
    #height = 160;                  // 真正的私有字段

    constructor(name) {
        this.name = name;
    }

    show() {
        console.log(this.name, this.#height);   // 類內部可訪問
    }
}

// console.log(obj.#height);        // 語法錯誤,外部無法訪問

# 前綴的私有字段是語法層面的限制,不像閉包那樣只是約定俗成,也不像 eval 那樣有性能和安全問題。本文這套推演的價值在於理解閉包、原型和 this 是如何咬合在一起的——理解之後,再用 class 你會知道它背後到底做了什麼。

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