另一种说法是，函数中的i在执行函数时绑定，而不是在创建函数时绑定。

当您创建闭包时，i是对外部范围中定义的变量的引用，而不是创建闭包时的副本。将在执行时进行评估。

大多数其他答案提供了通过创建另一个不会改变值的变量来解决问题的方法。

我只是想给你解释清楚。就我个人而言，为了解决这个问题，我会选择Harto的方法，因为从这里的答案来看，这是最不言自明的方法。发布的任何代码都可以使用，但我宁愿选择闭包工厂，而不必写一堆注释来解释为什么我要声明一个新变量（Freddy和1800）或具有奇怪的嵌入闭包语法（apphacker）。

通过ES6的新功能，可以管理块级范围：

var funcs = [];
for (let i = 0; i < 3; i++) {          // let's create 3 functions
    funcs[i] = function() {            // and store them in funcs
        console.log("My value: " + i); // each should log its value.
    };
}
for (let j = 0; j < 3; j++) {
    funcs[j]();                        // and now let's run each one to see
}

OP问题中的代码替换为let而不是var。

OP显示的代码的主要问题是，直到第二个循环才读取i。为了演示，想象一下在代码中看到一个错误

funcs[i] = function() {            // and store them in funcs
    throw new Error("test");
    console.log("My value: " + i); // each should log its value.
};

在执行funcs[someIndex]（）之前，错误实际上不会发生。使用相同的逻辑，应该很明显，直到这一点，i的值也不会被收集。一旦原始循环完成，i++将i值设为3，这导致条件i<3失败，循环结束。此时，i为3，因此当使用funcs[someIndex]（）时，每次计算i时，i均为3。

要克服这一点，必须在遇到i时对其求值。注意，这已经以funcs[i]的形式发生（其中有3个唯一索引）。有几种方法可以获取此值。一种是将其作为参数传递给函数，该函数在这里已经以多种方式显示。

另一种选择是构造一个函数对象，它将能够在变量上关闭。这样就可以完成

jsFiddle演示

funcs[i] = new function() {   
    var closedVariable = i;
    return function(){
        console.log("My value: " + closedVariable); 
    };
};

许多解决方案看起来都是正确的，但他们没有提到它叫做Currying，这是一种针对类似情况的函数式编程设计模式。根据浏览器的不同，比绑定快3-10倍。

var funcs = [];
for (var i = 0; i < 3; i++) {      // let's create 3 functions
  funcs[i] = curryShowValue(i);
}
for (var j = 0; j < 3; j++) {
  funcs[j]();                      // and now let's run each one to see
}

function curryShowValue(i) {
  return function showValue() {
    console.log("My value: " + i);
  }
}

查看不同浏览器中的性能增益。

JavaScript函数在声明时“关闭”它们有权访问的作用域，并保留对该作用域的访问权，即使该作用域中的变量发生变化。

var函数=[]对于（变量i=0；i<3；i+=1）{funcs[i]=函数（）{控制台日志（i）}}对于（var k=0；k<3；k+=1）{函数[k]（）}

上面数组中的每个函数都在全局范围（全局，因为这恰好是它们声明的范围）上关闭。

稍后调用这些函数，记录全局范围中i的最新值。这就是结束的魔力和挫折。

“JavaScript函数在声明它们的作用域上关闭，并保留对该作用域的访问权，即使该作用域内的变量值发生变化。”

使用let而不是var可以解决这个问题，方法是在每次for循环运行时创建一个新的作用域，为每个要关闭的函数创建一个单独的作用域。其他各种技术对额外的功能也有同样的作用。

var函数=[]for（设i=0；i<3；i+=1）{funcs[i]=函数（）{控制台日志（i）}}对于（var k=0；k<3；k+=1）{函数[k]（）}

（让变量成为块范围。块用大括号表示，但在for循环的情况下，初始化变量i在我们的情况下被认为是在大括号中声明的。）

计数器是基元

让我们如下定义回调函数：

// ****************************
// COUNTER BEING A PRIMITIVE
// ****************************
function test1() {
    for (var i=0; i<2; i++) {
        setTimeout(function() {
            console.log(i);
        });
    }
}
test1();
// 2
// 2

超时完成后，它将为两个打印2。这是因为回调函数访问基于词法范围的值，该范围是函数定义的地方。

为了在定义回调时传递和保留值，我们可以创建一个闭包，在调用回调之前保留值。这可以通过以下方式完成：

function test2() {
    function sendRequest(i) {
        setTimeout(function() {
            console.log(i);
        });
    }

    for (var i = 0; i < 2; i++) {
        sendRequest(i);
    }
}
test2();
// 1
// 2

现在，这一点的特殊之处在于“基元是按值传递并复制的。因此，当定义闭包时，它们会保留上一个循环的值。”

计数器是一个对象

由于闭包可以通过引用访问父函数变量，因此这种方法与原语不同。

// ****************************
// COUNTER BEING AN OBJECT
// ****************************
function test3() {
    var index = { i: 0 };
    for (index.i=0; index.i<2; index.i++) {
        setTimeout(function() {
            console.log('test3: ' + index.i);
        });
    }
}
test3();
// 2
// 2

因此，即使为作为对象传递的变量创建了闭包，也不会保留循环索引的值。这是为了表明对象的值不是复制的，而是通过引用访问的。

function test4() {
    var index = { i: 0 };
    function sendRequest(index, i) {
        setTimeout(function() {
            console.log('index: ' + index);
            console.log('i: ' + i);
            console.log(index[i]);
        });
    }

    for (index.i=0; index.i<2; index.i++) {
        sendRequest(index, index.i);
    }
}
test4();
// index: { i: 2}
// 0
// undefined

// index: { i: 2}
// 1
// undefined