JavaScript 模拟类机制及私有变量的方法及思路

在使用一些 Javascript 框架时，或许会看到类似的代码

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

这是一种典型的面向对象的类机制应用，与原生的 Javascript 类机制相比，显得更为清晰和自然。并且，在此基础上，实现类的继承也较为方便。那么，这是如何实现的呢？
众所周知，在 Javascript 中，将一个函数作为构造器，可以创建出一个对象，上面的代码可以简单的写成：

function MyClass(param) {
this.param = param;
this.func1 = function(..) {
...
};
}
var myObj = new MyClass(param);
myObj.func1();

其实还是蛮简单的，也不难理解。不过如果要构建一套大型的 Javascript 类库，可能就会比较混乱，从一堆代码中，要找出哪些是类，哪些是函数，哪些是类方法，哪些是类属性，是一件痛苦的事。
当然，这里并不是要比较它们的优劣，只是好奇 new Class 的实现方式而已。
在上面的代码中，使用 new MyClass() 这样的语句，意味着 MyClass 必须是一个函数，同时也就意味着 new Class 需要返回一个函数对象，从字面的意思上可以看出，函数 initialize 是当做构造函数来使用的，所以，new Class 返回的函数中，必须使用 initialize 来对对象进行初始化。基于这样的分析，可以得出以下代码：

function Class(argu) {
return function() {
var init = argu['initialize'] || function() {};  //如果没有构造函数 initialize，使用一个空函数作为默认构造函数
for(var p in argu) {
this[p] = argu[p];
}
init.apply(this, arguments); //使用当前函数的 this 来代替函数 initialize 原有的 this
}
}

上面的代码并不够严谨，但用来说明问题已经足够了。需要注意 init.apply(this, arguments) 这一句，这里有几个变量的指代，一个是 this，原本 initialize 中默认的 this，现在已被替代为返回的这个匿名函数的 this，而这个匿名函数，是通过 new Class 新建的自定义类的构造器。另外一个是 arguments，它指代的是匿名函数的参数，也就是上面的 new MyClass(param) 中的 param。
this 的转换有些让人头晕，那么有没有更为简单的方法呢？请看下面的代码：

function Class(argu) {
var obj = argu['initialize'] || function() {};
for(var p in argu) {
obj.prototype[p] = argu[p]; //注意，这里用的是 prototype
}
return obj; // 其實还是返回一個函數
}

呵呵，感觉直白了许多。
这就完成了一个简单的类机制的构建。通过这种机制，可以创建类的构造函数、方法及属性，但这些显然都是公有的，那么，如何实现私有变量及方法呢？
我们知道，Javascript 类的私有变量可以通过闭包的机制来完成。但使用 new Class({...}) 的方式转换后，显然很难形成有效的闭包。如何绕过这个问题呢？
Javascript 提供了两个方法：eval() 及函数对象的 toString() 方法，前者较为常见，而后者，可用于获取函数的具体代码。通过这两个方法，可以简单的模拟类的私有变量：

function Class(argu) {
var _ = argu['private'] || {};
eval('var obj = ' + (argu['initialize'] || function() {}).toString());
for(var p in argu) {
if(p == 'initialize' || p == 'private')
continue;
if(typeof argu[p] == 'function')
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 + '/nheight:' + _.height + '/nweight:' + _.weight);
}
});
var my = new Person("Zh");
my.show();

看起来不不错，不过在实际应用中，其实并没有太大的用途。主要是效率上，相比通常的实现方式，大概需要多花四倍的时间。在大型类库的构建上，这是不可容忍的，而小型的应用中，实现下面的代码更为简单直接：

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