计数器是基元

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

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

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

还有另一个解决方案：不要创建另一个循环，只需将this绑定到返回函数。

var函数=[]；函数createFunc（i）{返回函数（）{console.log（'我的值：'+i）//i的对数值。}.调用（this）；}对于（var i=1；i<=5；i++）{//5函数funcs[i]=创建Func（i）；//调用createFunc（）i=5次}

通过绑定它，也解决了问题。

  asyncIterable = [1,2,3,4,5,6,7,8];

  (async function() {
       for await (let num of asyncIterable) {
         console.log(num);
       }
    })();

这证明了javascript在“闭包”和“非闭包”的工作方式方面是多么丑陋。

在以下情况下：

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.
  };
}

funcs[i]是一个全局函数，并且'console.log（“我的值：”+i）；'正在打印全局变量i

假使

var funcs = [];

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

for (var i = 0; i < 3; i++) {
    funcs[i] = createfunc(i);
}

由于javascript的这种扭曲的闭包设计，'console.log（“我的值：”+i）；'正在从外部函数“createfunc（i）”打印i

这一切都是因为javascript无法像C编程语言那样在函数中设计出像“静态”变量这样的好东西！