闭包和类

闭包

先上维基百科的定义

在计算机科学中，闭包（英语：Closure），又称词法闭包（Lexical Closure）或函数闭包（function closures），是引用了自由变量的函数。这个被引用的自由变量将和这个函数一同存在，即使已经离开了创造它的环境也不例外。所以，有另一种说法认为闭包是由函数和与其相关的引用环境组合而成的实体。闭包在运行时可以有多个实例，不同的引用环境和相同的函数组合可以产生不同的实例。

简单理解这句话，有两个要点：
1. 自由变量 2. （引用自由变量的）函数。

先说自由变量:

当我们定义一个变量时，如果不对它指定约束条件，它就是自由变量。 举个例子：

x ∈  (0,99)
f(x,y)

在函数f(x,y)中，x就是约束变量，y是自由变量。

具体到JavaScript中，看一个例子：

var x = 0;
function foo (y) {
    var z = 2;
    return x + y + z;
}
foo (3); // 3

转换成数学思维的话，函数foo其实应该是这样的foo(x,y)，但是我们知道函数的参数其实是受到函数的约束的，也就是说，真正的自由变量只有x一个。
这样可以引出一个简单的定义，在函数中，如果存在一个既不是局部变量，也不是形参的变量，我们可以认为形成了闭包。

自由变量从哪儿来？

几乎所有的语言中，对于同名变量都是就近寻找，先在本作用域内寻找，找不到就去父作用域找。我们称之为作用域链。
在一个闭包函数中，自由变量通常是由父级提供。看下面的例子：

function foo(x) {
    var tmp = 3;
    function bar(y) {
        console.log(x + y + (++tmp));
    }
    bar(10);
}
foo(2)

根据我们上面的定义，bar拥有自由变量，是闭包，而foo不是。
那么怎样才能让foo变成闭包呢？

var x = 0;
function foo() {
    var tmp = 3;
    function bar(y) {
        console.log(x + y + (++tmp));
    }
    bar(10);
}
// 其实转换一下，形如
function foo2() {
    var tmp = 3;
    //function bar(y) {
        console.log(x + 10 + (++tmp));
    //}
    // bar(10);
}

此时，可以认为foo是一个闭包。
到这里，可能有朋友觉得这和平时看到的js闭包不一样啊，我们平时看到的闭包，都是这样的：例子来自这篇博客

function foo(x) {
    var tmp = new Number(3);
    return function (y) {
        alert(x + y + (++tmp));
    }
}
var bar = foo(2); // bar 现在是一个闭包
bar(10);

这个函数其实可以改写成下面的样子：

bar = function (y) {
    // foo(2)
    alert(2 + y + (++tmp))
}

很明显，tmp是自由变量，符合我们起初的定义，bar是拥有自由变量的函数。
那么tmp存在哪儿呢？
在执行foo(2)时，就会产生一个tmp=3的变量。这个变量被return的函数所引用，所以不会被回收。而return的函数中的自由变量，根据作用域链去寻找值。bar函数，是在foo(2)中定义的，所以，变量tmp先在foo(2)的变量区中去寻找，并对其操作。

注：有关作用域链的问题，我会在下一篇做解析。

说到这里，插一下module模式。

闭包使用之module模式

var Module = (function () {
    var aaa = 0;
    var foo = function () {
        console.log(aaa);
    }
    
    return {
        Foo: foo
    }
})();
// 或者
(function () {
    var aaa = 0;
    var foo = function () {
        console.log(aaa);
    }
    
    window.Module = {
        Foo: foo
    }
})();

注意上面的两个例子，Module本身只是一个对象，但是return的函数本身形成了闭包，保证了作用域的干净，不会污染到其他函数。

说到这里，想必有朋友觉得这不就是个另类的类吗？拥有局部变量，还有可访问的函数。没错，就外现而言，我认为闭包和类是非常相似的。

类

以Java举例：

class Foo {
    private int a;
    int Say( int b ) {
        return a + b; 
    }  
}

上面的Foo中，函数Say中的a是函数作用域外的，属于自由变量。可以认为Say形成了函数闭包。但是与js不同的地方就在于，实例方法需要通过类的实例也就是对象来调用。
在java的设计里，明确了访问权限，private，protect，default，package，这是规范调用的创举。这也使得java程序员很少会考虑闭包这种实现，因为变量和函数都有关键字来定义访问权限，归属于一个个类中，明确且清晰。

闭包的坏处

如果把闭包按照类的实现来理解的话，很容易就明白为什么不建议使用闭包。
每次调用闭包，就会生成一个作用域来存放一些闭包函数需要的自由变量。这很容易造成内存浪费。即使在Java编程中，也不建议随便就新建对象。

题外话

在前一篇bind、call、apply中，我提到了一个观点，因为是面向对象，所以存在绑定this的需要。
关于面向对象，我认为，面向对象的好处就在于，易于理解，方便维护和复用。这在多人开发大型项目时，是远远超过对性能的要求的。
即使在摩尔定律放缓的现在，相对于以前，内存也是非常便宜的，所以从远古时代对于性能要求到极致，到现在普遍提倡代码可读性。
有超级大牛创建了这个缤纷的代码世界，为了让更多人体会到编程的乐趣，他们设计了更易理解的编程语言，发明了各种编译器、解析器……
如果只是写一个1+1的程序，是不需要面向对象的，如果人类能和机器拥有超强的逻辑和记忆，也是不需要面向对象的。