在阅读了各种解决方案之后，我想补充一点，这些解决方案之所以有效，是因为依赖于范围链的概念。这是JavaScript在执行期间解析变量的方式。

每个函数定义形成一个范围，该范围由所有本地var声明的变量及其参数。如果我们在另一个（外部）函数中定义了内部函数形成一条链，并将在执行过程中使用当函数被执行时，运行时通过搜索作用域链来评估变量。如果在链的某个点上可以找到一个变量，它将停止搜索并使用它，否则将继续搜索，直到到达属于window的全局范围。

在初始代码中：

funcs = {};
for (var i = 0; i < 3; i++) {         
  funcs[i] = function inner() {        // function inner's scope contains nothing
    console.log("My value: " + i);    
  };
}
console.log(window.i)                  // test value 'i', print 3

当执行funcs时，作用域链将是函数inner->global。由于在函数内部找不到变量i（既没有使用var声明，也没有作为参数传递），因此它继续搜索，直到最终在全局范围（即window.i）中找到i的值。

通过将其包装在外部函数中，要么像harto那样显式定义助手函数，要么像Bjorn那样使用匿名函数：

funcs = {};
function outer(i) {              // function outer's scope contains 'i'
  return function inner() {      // function inner, closure created
   console.log("My value: " + i);
  };
}
for (var i = 0; i < 3; i++) {
  funcs[i] = outer(i);
}
console.log(window.i)          // print 3 still

当执行funcs时，现在作用域链将是函数inner->函数outer。这一次，可以在for循环中执行3次的外部函数的作用域中找到i，每次都有正确绑定的值i。当内部执行时，它不会使用window.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]（）；}

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

您需要了解的是javascript中变量的范围是基于函数的。这与c#有一个重要的区别，因为c#有块作用域，只需将变量复制到for中的一个即可。

将其包装在一个函数中，该函数会像apphacker的答案那样计算返回函数的值，这会起到作用，因为变量现在具有函数作用域。

还有一个let关键字而不是var，这将允许使用块范围规则。在这种情况下，在for中定义一个变量就可以了。也就是说，由于兼容性，let关键字不是一个实用的解决方案。

var funcs=｛｝；对于（变量i=0；i<3；i++）{设索引=i//添加此funcs[i]=函数（）{console.log（“我的值：”+索引）//更改副本};}对于（变量j=0；j<3；j++）{函数[j]（）；}

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

这个问题确实展示了JavaScript的历史！现在，我们可以避免使用箭头函数的块作用域，并使用Object方法直接处理来自DOM节点的循环。

常量函数=[1，2，3].map（i=>（）=>console.log（i））；函数映射（fn=>fn（））

const buttons=document.getElementsByTagName（“button”）；对象按键（按钮）.map（i=>按钮[i].addEventListener（'click'，（）=>console.log（i）））；<button>0</button><br><button>1</button><br><按钮>2</按钮>

我们将检查，当您声明var并让逐一地。

案例1：使用var

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

现在，按F12打开铬控制台窗口并刷新页面。在数组中每3个函数展开一次。您将看到一个名为[[Scopes]]的属性。展开该属性。你会看到一个名为“Global”的数组对象，展开该对象。您将发现对象中声明的属性“i”具有值3。

结论：

当您在函数外部使用“var”声明变量时，它将变为全局变量（您可以通过键入i或window.i。它将返回3）。除非调用功能。调用函数时，console.log（“My value:”+i）从其Global对象中获取值，并显示后果

CASE2：使用let

现在将“var”替换为“let”

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

做同样的事情，去观察镜。现在您将看到两个对象“块”和“全局”。现在展开Block对象将看到这里定义了“i”，奇怪的是，对于每个函数，如果i不同（0，1，2），则其值是不同的。

结论：

当您在函数外部但在循环内部使用“let”声明变量时，此变量将不是全局变量变量，它将成为块级变量，仅可用于同一函数。这就是为什么，我们调用函数时，每个函数的i值都不同。

有关更紧密的工作原理的更多信息，请浏览精彩的视频教程https://youtu.be/71AtaJpJHw0