虽然这个问题已经过时并得到了解答，但我还有另一个相当有趣的解决方案：

var funcs = [];

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

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

变化很小，几乎很难看出我做了什么。我将第二个迭代器从j切换到I。这会及时刷新I的状态，从而获得所需的结果。我这样做是偶然的，但考虑到以前的答案，这是有道理的。

我写这篇文章是为了指出这一微小但非常重要的区别。希望这有助于为像我这样的其他学习者澄清一些困惑。

注：我没有分享这个，因为我认为这是正确的答案。这是一个在某些情况下可能会破裂的解决方案。事实上，我很惊讶它真的有效。

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

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

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

另一种尚未提及的方法是使用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]（）；}

你的代码不起作用，因为它的作用是：

Create variable `funcs` and assign it an empty array;  
Loop from 0 up until it is less than 3 and assign it to variable `i`;
    Push to variable `funcs` next function:  
        // Only push (save), but don't execute
        **Write to console current value of variable `i`;**

// First loop has ended, i = 3;

Loop from 0 up until it is less than 3 and assign it to variable `j`;
    Call `j`-th function from variable `funcs`:  
        **Write to console current value of variable `i`;**  
        // Ask yourself NOW! What is the value of i?

现在问题是，调用函数时变量i的值是多少？因为第一个循环是在i<3的条件下创建的，所以当条件为false时，它会立即停止，所以它是i=3。

您需要理解，当您的函数被创建时，它们的代码都不会被执行，只会被保存以备以后使用。因此，当稍后调用它们时，解释器会执行它们并问：“i的当前值是多少？”

因此，您的目标是首先将i的值保存到函数，然后才将函数保存到funcs。例如，可以这样做：

var funcs = [];
for (var i = 0; i < 3; i++) {          // let's create 3 functions
    funcs[i] = function(x) {            // and store them in funcs
        console.log("My value: " + x); // each should log its value.
    }.bind(null, i);
}
for (var j = 0; j < 3; j++) {
    funcs[j]();                        // and now let's run each one to see
}

这样，每个函数都有自己的变量x，我们在每次迭代中将这个x设置为i的值。

这只是解决这个问题的多种方法之一。

我们将检查，当您声明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

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