用過一些 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 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 你會知道它背後到底做了什麼。