如果您在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++；}

最初的示例不起作用的原因是，您在循环中创建的所有闭包都引用了同一帧。实际上，一个对象上有3个方法，只有一个i变量。他们都打印出相同的值。

另一种尚未提及的方法是使用Function.prototype.bind

var funcs=｛｝；对于（变量i=0；i<3；i++）{funcs[i]=函数（x）{console.log（'我的值：'+x）；}.绑定（this，i）；}对于（变量j=0；j<3；j++）{函数[j]（）；}

更新

正如@squit和@mekdev所指出的，通过首先在循环外创建函数，然后在循环内绑定结果，可以获得更好的性能。

函数日志（x）{console.log（'我的值：'+x）；}var函数=[]；对于（变量i=0；i<3；i++）{funcs[i]=log.bind（this，i）；}对于（变量j=0；j<3；j++）{函数[j]（）；}

首先，了解此代码的错误：

var funcs = [];
for (var 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 (var j = 0; j < 3; j++) {
    funcs[j]();                        // and now let's run each one to see
}

这里，当funcs[]数组初始化时，i递增，funcs数组初始化，func数组的大小变为3，因此i=3，。现在，当调用funcs[j]（）时，它再次使用变量i，变量i已经增加到3。

现在要解决这个问题，我们有很多选择。以下是其中两个：

我们可以用let初始化i，或者用let初始化一个新的变量索引，并使其等于i。因此，当进行调用时，将使用索引，其范围将在初始化后结束。对于调用，索引将再次初始化：var函数=[]；对于（var i=0；i<3；i++）{设索引=i；funcs[i]=函数（）｛console.log（“我的值：”+索引）；};}对于（变量j=0；j<3；j++）{函数[j]（）；}其他选项可以是引入一个返回实际函数的tempFunc：var函数=[]；函数tempFunc（i）{返回函数（）{console.log（“我的值：”+i）；};}对于（var i=0；i<3；i++）{funcs[i]=tempFunc（i）；}对于（变量j=0；j<3；j++）{函数[j]（）；}

我更喜欢使用forEach函数，它有自己的闭包，可以创建伪范围：

var funcs = [];

new Array(3).fill(0).forEach(function (_, i) { // creating a range
    funcs[i] = function() {            
        // now i is safely incapsulated 
        console.log("My value: " + i);
    };
});

for (var j = 0; j < 3; j++) {
    funcs[j](); // 0, 1, 2
}

这看起来比其他语言的范围更丑陋，但IMHO比其他解决方案更不可怕。

计数器是基元

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

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