JavaScript闭包与变量的经典问题

许多人第一次接触闭包大概都是从高程里这段代码开始的：

function createFunctions() {

    var result = new Array();
 
    for(var i=0; i<10; i++) {
        result[i] = function() {
            return i;
        }
    }

    return result;
}

var foo = createFunctions();

或者是用for循环在给网页中一连串元素绑定例如onclick事件时
所有的教材在讲到这一点时都会给出这样的解释： 因为每个函数都保存着createFunction中的活动对象，所以它们引用的都是同一个变量 i 。而循环结束后 i 的值为10，所以每个函数的输出都是10.

解释非常简洁与正确。

然而还是会有一部分人看了这个解释后一知半解，比如我。

我第一次看到这个解释后有了这么一连串疑问： 虽然知道 i 最终是 10，但是在每次赋值过程中 i 并不是 10 啊，为什么非要取最后一个值呢？i 并不是引用数据类型，为什么可以说“它们引用的都是同一个变量 i ？

如果你和我一样有这个疑问，其实对这个问题而言我们不理解的地方并不是闭包，但是这个问题被打上了一个严重的”闭包“标签，导致很长一段时间里我都以为自己不了解闭包。

实际上，我不理解的并不是闭包这个概念，而是更为基础的，函数调用的时机。

我们把代码中赋值的那一段改一下：

result[i] = function() {
    return j;
}

把 i 改成 j， 一个并没有定义的变量。

如果我们仅仅把改完之后的代码贴到console里运行,它是不会报错的。因为虽然createFunctions被调用了，却并未调用赋给result的匿名函数。

只有继续使用语句调用result中的某个元素：

result[0]()

这样才会抛出 undefined 错误。

这说明了一个问题：仅仅声明某一个函数，引擎并不会对函数内部的任何变量进行查找或赋值操作。只会对函数内部的语法错误进行检查（如果往内部函数加上非法语句，那么不用调用也会报错）。只有调用该函数时，才会进行变量寻找。

所以开头问题里的循环语句：

for(var i=0; i<10; i++)
    result[i] = function()
        return i;

我原本以为它是这样的：

result[0] = function() { return 0; }；
result[1] = function() { return 1; }；
result[2] = function() { return 2; }；

实际上它是这样的：

result[0] = function() { return i; }；
result[1] = function() { return i; }；
result[2] = function() { return i; }；

数组里的 i 和 函数里的 i 并不是一回事， 外面的是常量， 里面的是变量。

而当我们调用result[0]函数时， 这个函数执行到 return 语句，发现并没有 i 这个变量，于是顺着作用链去找，在createFunctions里找到了已经变成10的 i ，于是输出 10. 这个过程才是闭包的寻找变量的过程。

根据这个思路寻找解决方案时思路就明确多了，只要在每次赋值过程中，不让 i 作为变量，而是确确实实地利用当时 i 的值，方法就是将 i 作为函数参数进行调用：

result[i] = (function(val) { return val; })(i)；

这样一来在每一次赋值的过程中，每一个result[i]都与 i 的当前值产生了联系。

当然，这样修改的问题在于，原题返回的是一个函数，这里返回的却是一个值。

所以还要把返回值改成相应的函数：

result[i] = (function (val) {
    return function () {
        return val
    }
})(i)

这样相当于给目标函数套上了一层块级作用域，并且在 i 每次循环时都将它的值赋给了这个块级作用域中的一个临时变量val。这个临时变量其实和 i 没有太大区别，只不过 i 在它的作用域声明时值为 0 ，结束后变成了10。而对每个临时变量而言，开始是多少，结束还是多少。

其实就是这样：

result[0] = function() { return val; }；//val = i = 0
result[1] = function() { return val; }；//val = i = 1
result[2] = function() { return val; }；//val = i = 2

这里给出最终版代码：

function func() {
    var result = new Array;

    for(var i = 0;i<10;i++){
        result[i] = function (val) {
            return  function () {
                return val
            }
        }(i)
    }
    return result;
}

var results = func();
results.forEach(function (element) {
    console.log(element());//0 1 2 3 4 5 6 7 8 9
});

进一步谈闭包

任何声明在另一个函数内部的函数都可以称为闭包。也就是说，闭包是一个函数。不过也有些地方会讲闭包是内部函数以及其作用域链组成的一个整体。两种说法其实一个意思，毕竟严格来说，函数的作用域也是函数的一部分。不过我更喜欢后面一种说法，因为它强调了闭包的重点：维持作用域。

闭包主要有两个概念：可以访问外部函数，维持函数作用域。第一个概念并没有什么特别，大部分编程语言都有这个特性，内部函数可以访问其外部变量这种事情很常见。所以重点在于第二点。举例如下：

var globalValue;
 
function out() {
    var value = 1;
    function inner() {
        return value;
    }
    globalValue = inner;
}
 
out();
 
globalValue() // return 1;

我们先不考虑闭包地看一下这个问题：首先声明了一个全局变量，然后调用了out函数，调用函数的过程中全局变量被赋值了一个函数。out函数调用结束之后，按照内存处理机制，它内部的所有变量应该都被释放掉了，不过还好我们把inner复制给了全局变量，所以还可以在外部调用它。接下来我们调用了全局变量，这时候因为out内部作用域已经被释放了，所以应该找不到value的值，返回应该是undefined。

但是事实是，它的确返回了 1，即内部变量。本该已经消失了，只能存在于out函数内部的变量，走到了墙外。这就是闭包的强大之处。