闭包和类

闭包

先上维基百科的定义

在计算机科学中，闭包（英语：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的程序，是不须要面向对象的，若是人类能和机器拥有超强的逻辑和记忆，也是不须要面向对象的。