js闭包

高阶函数除了可以接受函数作为参数外，还可以把函数作为结果值返回。

比如一个求和函数，在后面的代码中，根据需要再计算。就可以不返回求和的结果，而是返回求和的函数

　　function lazy_sum(arr) {
        var sum = function() {
            return arr.reduce(function(x,y) {
                return x + y;
            });
        }
        return sum;
    }

当我们调用lazy_sum()的时候，返回的并不是求和结果，而是求和函数：

var f = lazy_sum([1,2,3,4,5]);//function sum()

调用函数f时，才是真正计算求和的结果：

f();//15

我们在函数lazy_sum中又定义了函数sum，并且，内部函数sum可以引用外部函数lazy_sum的参数和局部变量，当lazy_sum返回函数sum时，相关参数和变量都保存在返回的函数中。这种称为“闭包（Closeure）”的程序结构拥有极大的威力。

当我们调用lazy_sum()时，每次调用都会返回一个新的函数，即使传入相同的参数：

　　var f1 = lazy_sum([1,2,3,4,5]);
    var f2 = lazy_sum([1,2,3,4,5]);
    f1 === f2;//false

f1()和f2()的调用结果 互不影响。

闭包

注意到返回的函数在其定义内部引用了局部变量arr，所以，当一个函数返回一个函数后，其内部的局部变量还被新函数引用。

注意，返回的函数并没有立即执行，而是直到调用了f()才执行。

　　function count() {
        var arr = [];
        for(var i =1;i<3;i++) {
            arr.push(function (){
                return i*1;
            });
        }
        return arr;
    }

    var results = count();
    var f1 = results[0];
    var f2 = results[1];
    var f3 = results[2];

在上面的例子中，每次循环，都创建了一个新的函数，然后，把创建的3个函数都添加到一个Array中返回了。

实际结果是

　　f1();//16
    f2();//16
    f3();//16

结果全部是16的原因就在于返回的函数引用了变量i，但它并非立即执行。等到3个函数都返回时，他们所引用的变量都变成了4，因此最终结果为16。

返回闭包时牢记一点就是：返回函数不要引用任何变量。或者后续会发生变化的变量。

如果一定要引用循环变量，方法就是再创建一个函数，用该函数的参数绑定循环变量当前的值，无论该循环变量后续如何更改，已绑定到函数参数的值不变：

　　function count() {
        var arr = [];
        for(var i=1;i<3;i++) {
            arr.push((function (n){
                return function(){
                    return n*n;
                }
            })(i));
        }
        return arr;
    }
    var results = count();
    var f1 = results[0];
    var f2 = results[0];
    var f3 = results[0];

    f1();//1
    f2();//4
    f3();//9

这里用了一个“创建一个匿名函数并立刻执行”的语法

　　(function (x) {
        return x*x;
    })(3);//9

由于JavaScript语法解析的问题，会报SyntaxError错误，因此需要用括号把整个函数定义包起来。

在没有class机制，只有函数的语言里，借助闭包，同样可以封装一个私有变量。我们用JavaScript创建一个计数器：

　　function create_counter(initial) {
        var x = initial || 0;
        return {
            inc:function () {
                x+=1;
                return x;
            }
        }
    }

用起来就是这样：

　　var c1 = create_counter();
    c1.inc();//1
    c1.inc();//2
    c1.inc();//3

    var c2 = create_counter(10);
    c2.inc();//11
    c2.inc();//12
    c2.inc();//13

在返回的对象中，实现了一个闭包，该闭包携带了局部变量x，并且，从外部代码根本无法访问到变量x。换句话说，闭包就是携带状态的函数，并且它的状态完全对外隐藏起来。

闭包还可以把多参数的函数变成单参数的函数。例如。要计算x的y次方可以用Math.pow(x,y)函数，不过考虑到经常计算x²或者x三次方，我们可以利用闭包创建新的函数pow2和pow3：

　　　　function make_pow(n) {
            return function (x) {
                return Math.pow(x,n);
            }
        }
        //创建两个新函数
        var pow2 = make_pow(2);
        var pow3 = make_pow(3)

        pow2(5);//25
        pow3(7);//343