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; // 其还是返回一函br /> }
呵呵，感觉直白了许多。
这就完成了一个简单的类机制的构建。通过这种机制，可以创建类的构造函数、方法及属性，但这些显然都是公有的，那么，如何实现私有变量及方法呢？
我们知道，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);
};
}