js 闭包 弊端

闭包有许多有趣的用途，Javascript的两个特征使它这么有趣：1. function是一个对象，它跟数组，Object一样，地位平等。2. Javascript变量作用域范围。《Javascript权威指南》对这两点有深入的讲解。

闭包有一个著名的用途就是实现面向对象的访问控制。也就是c++, c#, java等面向对象的private, public访问控制。先看一段示例代码

<script type="text/javascript">
function ClassA(){
var a = 4;
this.get_a = function(){
return a;
};
this.set_a = function(value){
a = value;
};
}

var v = new ClassA();
document.write(v.get_a()+"<br />"); //显示4
v.set_a(1);
document.write(v.get_a()+"<br />"); //显示1
alert(v.a); //显示undefined
</script>

上面的代码很简单，只是把数据成员a的访问器(setter/ getter)，放在了构造函数中。a使用var声明，外面不能直接访问a。get_a和set_a都用this来使得这两个函数与类对象关联，并且外面可见。

上面的方法很有技巧，但我从没有这样做过，微软的AJAX.NET也没有利用闭包来实现访问控制。原因是它要占用更多的内存，下面说说它为什么要占用更多的内存。

首先，我们使用原型(prototype)来定义一个类

<script type="text/javascript">
function ClassA(){
}
ClassA.prototype = {
fun1: function(){
document.write("prototype fun1 <br /><br />");
}
}

var a = new ClassA();
var b = new ClassA();
a.fun1(); //prototype fun1
b.fun1(); //prototype fun1
ClassA.prototype.fun1 = function(){
document.write("modify function<br /><br />");
}
a.fun1(); //modify function
b.fun1(); //modify function
a.fun1 = function(){
document.write("modify a's method<br /><br />");
}
a.fun1();
b.fun1();
</script>

从上面的运行结果可以看出，使用prototype定义的类，实例化出来的对象都共享同一个方法，一旦原型改变了，会影响全部对象。而一个对象修改了自身的方法，系统会执行copy on write，把对象指向新的方法而不会影响其他对象。

再看看以下这一段:

<script type="text/javascript">
function ClassA(){
this.fun1 = function(){
document.write("object function <br />");
};
}
var a = new ClassA();
var b = new ClassA();
a.fun1();
b.fun1();
ClassA.prototype.fun1 = function(){
document.write("modify object function <br />");
}
a.fun1();
b.fun1();
a.fun1 = function(){
document.write("modify a's function <br />");
}
a.fun1();
b.fun1();
</script>

从运行结果可以看到，闭包的结果是每个对象都拥有独立的方法，即使对象之间的方法的实现一模一样。这样会造成多余的内存浪费。试想想，如果一个使用闭包的类实例了许多个对象，那么会浪费多少内存？