随着ES6现在得到广泛支持，这个问题的最佳答案已经改变。ES6为这种情况提供了let和const关键字。我们可以使用let来设置一个循环范围变量，而不是使用闭包：

var函数=[]；对于（设i=0；i<3；i++）{funcs[i]=函数（）｛console.log（“我的值：”+i）；};}

然后，val将指向一个特定于循环特定转弯的对象，并将返回正确的值，而无需附加闭包符号。这显然大大简化了这个问题。

const类似于let，但有一个额外的限制，即变量名不能在初始赋值后反弹到新引用。

现在，针对最新版本浏览器的浏览器提供了浏览器支持。const/let目前在最新的Firefox、Safari、Edge和Chrome中受支持。Node也支持它，您可以利用Babel等构建工具在任何地方使用它。您可以在这里看到一个工作示例：http://jsfiddle.net/ben336/rbU4t/2/

此处的文档：

常量允许

不过，请注意，IE9-IE11和Edge 14之前的Edge支持以上错误（它们不会每次都创建一个新的i，所以上面的所有函数都会记录3，就像我们使用var时一样）。边缘14最终得到了正确的结果。

计数器是基元

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

// ****************************
// 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

Try:

var函数=[]；对于（变量i=0；i<3；i++）{funcs[i]=（函数（索引）{返回函数（）{console.log（“我的值：”+索引）；};}（i） ）；}对于（变量j=0；j<3；j++）{函数[j]（）；}

编辑（2014）：

就我个人而言，@Aust最近关于使用.bind的回答是目前最好的解决方法。当您不需要或不想使用bind的thisArg时，也可以使用破折号/下划线的_.partial。

使用封闭结构，这将减少额外的for循环。您可以在单个for循环中执行此操作：

var funcs = [];
for (var i = 0; i < 3; i++) {     
  (funcs[i] = function() {         
    console.log("My value: " + i); 
  })(i);
}

通过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。

如果您在while循环而不是for循环中遇到此类问题，例如：

变量i=0；而（i<5）{setTimeout（函数）{控制台日志（i）；}，i*1000）；i++；}

关闭当前值的技术有点不同。在while块内声明一个带有const的块范围变量，并将当前i赋给它。然后，无论在何处异步使用该变量，都用新的块范围的变量替换i：

变量i=0；而（i<5）{常量this迭代i=i；setTimeout（函数）{console.log（thisIterationI）；}，i*1000）；i++；}

对于不支持块作用域变量的旧浏览器，可以使用IIFE，调用i：

变量i=0；而（i<5）{（函数（innerI）{setTimeout（函数）{console.log（innerI）；}，innerI*1000）；})（i） ；i++；}

如果要调用的异步操作恰好是如上所述的setTimeout，则还可以使用第三个参数调用setTimeout以指示调用传递函数的参数：

变量i=0；而（i<5）{setTimeout（设置超时）(（thisIterationI）=>｛//回调console.log（thisIterationI）；},i*1000，//延迟i//获取传递给回调函数的值；成为此迭代I);i++；}