最简单的解决方案是，

而不是使用：

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

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

警报“2”3次。这是因为在for循环中创建的匿名函数共享相同的闭包，并且在该闭包中，i的值是相同的。使用此选项可防止共享关闭：

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

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

这背后的想法是，用IIFE（立即调用函数表达式）封装for循环的整个主体，并将new_i作为参数传递，并将其捕获为i。由于匿名函数是立即执行的，因此匿名函数内部定义的每个函数的i值都不同。

此解决方案似乎适合任何此类问题，因为它需要对受此问题困扰的原始代码进行最小的更改。事实上，这是故意的，根本不应该是一个问题！

聚会的时间有点晚了，但我今天正在探讨这个问题，并注意到许多答案并没有完全解决Javascript如何处理作用域的问题，这本质上就是问题的根源。

所以正如许多其他人提到的，问题是内部函数引用的是同一个i变量。那么为什么我们不在每次迭代时都创建一个新的局部变量，并让内部函数引用它呢？

//覆盖console.log（），以便可以看到控制台输出console.log=函数（消息）｛document.body.innerHTML+='<p>'+msg+'</p>'；｝；var funcs=｛｝；对于（变量i=0；i<3；i++）{var ilocal=i//创建新的局部变量funcs[i]=函数（）{console.log（“我的值：”+ilocal）//每个都应该引用自己的局部变量};}对于（变量j=0；j<3；j++）{函数[j]（）；}

就像之前一样，每个内部函数输出分配给i的最后一个值，现在每个内部函数只输出分配给ilocal的最后一值。但每个迭代不应该有自己的ilocal吗？

事实证明，这就是问题所在。每个迭代都共享相同的范围，因此第一次迭代之后的每个迭代都只是覆盖ilocal。来自MDN：

重要提示：JavaScript没有块范围。随块引入的变量的作用域是包含函数或脚本，设置这些变量的效果将持续到块本身之外。换句话说，块语句不引入范围。尽管“独立”块是有效的语法，但您不希望在JavaScript中使用独立块，因为如果您认为它们在C或Java中做类似的事情，它们不会做您认为它们做的事情。

再次强调：

JavaScript没有块范围。随块引入的变量的作用域是包含函数或脚本

通过在每次迭代中声明ilocal之前检查ilocal，我们可以看到这一点：

//覆盖console.log（），以便可以看到控制台输出console.log=函数（消息）｛document.body.innerHTML+='<p>'+msg+'</p>'；｝；var funcs=｛｝；对于（变量i=0；i<3；i++）{console.log（ilocal）；var ilocal=i；}

这正是这个bug如此棘手的原因。即使您正在重新定义变量，Javascript也不会抛出错误，JSLint甚至不会抛出警告。这也是为什么解决这一问题的最佳方法是利用闭包，这本质上就是在Javascript中，内部函数可以访问外部变量，因为内部作用域“包围”外部作用域。

这也意味着内部函数“抓住”外部变量并保持它们的活力，即使外部函数返回。为了利用这一点，我们创建并调用一个包装函数来创建一个新的作用域，在新作用域中声明ilocal，并返回一个使用ilocal的内部函数（下面有更多解释）：

//覆盖console.log（），以便可以看到控制台输出console.log=函数（消息）｛document.body.innerHTML+='<p>'+msg+'</p>'；｝；var funcs=｛｝；对于（变量i=0；i<3；i++）{funcs[i]=（function（）｛//使用包装函数创建新范围var ilocal=i//将i捕获到本地var中return function（）｛//返回内部函数console.log（“我的值：”+ilocal）；};})(); //记住运行包装器函数}对于（变量j=0；j<3；j++）{函数[j]（）；}

在包装器函数内创建内部函数为内部函数提供了一个只有它才能访问的私有环境，即“闭包”。因此，每次调用包装器函数时，我们都会创建一个新的内部函数，并使用它自己的独立环境，确保ilocal变量不会相互冲突和覆盖。一些小的优化给出了许多其他SO用户给出的最终答案：

//覆盖console.log（），以便可以看到控制台输出console.log=函数（消息）｛document.body.innerHTML+='<p>'+msg+'</p>'；｝；var funcs=｛｝；对于（变量i=0；i<3；i++）{funcs[i]=包装器（i）；}对于（变量j=0；j<3；j++）{函数[j]（）；}//为内部函数创建单独的环境函数包装器（ilocal）{return function（）｛//返回内部函数console.log（“我的值：”+ilocal）；};}

使现代化

随着ES6成为主流，我们现在可以使用新的let关键字来创建块范围的变量：

//覆盖console.log（），以便可以看到控制台输出console.log=函数（消息）｛document.body.innerHTML+='<p>'+msg+'</p>'；｝；var funcs=｛｝；for（设i=0；i<3；i++）{//使用“let”声明“i”funcs[i]=函数（）{console.log（“我的值：”+i）//每个都应该引用自己的局部变量};}对于（var j=0；j<3；j++）{//我们可以在这里使用“var”函数[j]（）；}

看看现在有多容易！有关更多信息，请参阅此答案，我的信息基于此。

Try:

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

编辑（2014）：

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

这是该技术的另一种变体，类似于Bjorn（apphacker），它允许您在函数内分配变量值，而不是将其作为参数传递，这有时可能更清楚：

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

请注意，无论使用何种技术，索引变量都会成为一种静态变量，绑定到内部函数的返回副本。即，在调用之间保留对其值的更改。它可以非常方便。

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

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