OP显示的代码的主要问题是，直到第二个循环才读取i。为了演示，想象一下在代码中看到一个错误

funcs[i] = function() {            // and store them in funcs
    throw new Error("test");
    console.log("My value: " + i); // each should log its value.
};

在执行funcs[someIndex]（）之前，错误实际上不会发生。使用相同的逻辑，应该很明显，直到这一点，i的值也不会被收集。一旦原始循环完成，i++将i值设为3，这导致条件i<3失败，循环结束。此时，i为3，因此当使用funcs[someIndex]（）时，每次计算i时，i均为3。

要克服这一点，必须在遇到i时对其求值。注意，这已经以funcs[i]的形式发生（其中有3个唯一索引）。有几种方法可以获取此值。一种是将其作为参数传递给函数，该函数在这里已经以多种方式显示。

另一种选择是构造一个函数对象，它将能够在变量上关闭。这样就可以完成

jsFiddle演示

funcs[i] = new function() {   
    var closedVariable = i;
    return function(){
        console.log("My value: " + closedVariable); 
    };
};

您需要了解的是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]（）；}

在阅读了各种解决方案之后，我想补充一点，这些解决方案之所以有效，是因为依赖于范围链的概念。这是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中使用闭包的常见错误。

函数定义新环境

考虑：

function makeCounter()
{
  var obj = {counter: 0};
  return {
    inc: function(){obj.counter ++;},
    get: function(){return obj.counter;}
  };
}

counter1 = makeCounter();
counter2 = makeCounter();

counter1.inc();

alert(counter1.get()); // returns 1
alert(counter2.get()); // returns 0

每次调用makeCounter时，｛counter:0｝都会创建一个新对象。另外，obj的新副本也被创建以引用新对象。因此，计数器1和计数器2彼此独立。

回路中的闭合

在循环中使用闭包很棘手。

考虑：

var counters = [];

function makeCounters(num)
{
  for (var i = 0; i < num; i++)
  {
    var obj = {counter: 0};
    counters[i] = {
      inc: function(){obj.counter++;},
      get: function(){return obj.counter;}
    }; 
  }
}

makeCounters(2);

counters[0].inc();

alert(counters[0].get()); // returns 1
alert(counters[1].get()); // returns 1

请注意，计数器[0]和计数器[1]不是独立的。事实上，它们对同一个对象进行操作！

这是因为在循环的所有迭代中只有一个obj副本共享，可能是出于性能原因。即使｛counter:0｝在每次迭代中都创建了一个新对象，obj的同一副本也只会用对最新对象的引用。

解决方案是使用另一个助手函数：

function makeHelper(obj)
{
  return {
    inc: function(){obj.counter++;},
    get: function(){return obj.counter;}
  }; 
}

function makeCounters(num)
{
  for (var i = 0; i < num; i++)
  {
    var obj = {counter: 0};
    counters[i] = makeHelper(obj);
  }
}

这是因为直接分配了函数范围中的局部变量以及函数参数变量新副本。

另一种说法是，函数中的i在执行函数时绑定，而不是在创建函数时绑定。

当您创建闭包时，i是对外部范围中定义的变量的引用，而不是创建闭包时的副本。将在执行时进行评估。

大多数其他答案提供了通过创建另一个不会改变值的变量来解决问题的方法。

我只是想给你解释清楚。就我个人而言，为了解决这个问题，我会选择Harto的方法，因为从这里的答案来看，这是最不言自明的方法。发布的任何代码都可以使用，但我宁愿选择闭包工厂，而不必写一堆注释来解释为什么我要声明一个新变量（Freddy和1800）或具有奇怪的嵌入闭包语法（apphacker）。

试试这个短一点的

无阵列没有额外的for循环

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

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

http://jsfiddle.net/7P6EN/