问题是，每个匿名函数中的变量i都绑定到函数外部的同一变量。

ES6解决方案：让

ECMAScript 6（ES6）引入了新的let和const关键字，它们的作用域不同于基于var的变量。例如，在具有基于let的索引的循环中，循环中的每个迭代都将有一个具有循环范围的新变量i，因此您的代码将按预期工作。有很多资源，但我推荐2ality的块范围帖子作为一个很好的信息来源。

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

不过，请注意，IE9-IE11和Edge 14之前的Edge支持以上错误（它们不会每次都创建一个新的i，所以上面的所有函数都会记录3，就像我们使用var时一样）。边缘14最终得到了正确的结果。

ES5.1解决方案：针对每个

随着Array.prototype.forEach函数的广泛使用（2015年），值得注意的是，在那些主要涉及对值数组进行迭代的情况下，.forEach（）提供了一种干净、自然的方式，可以为每次迭代获得一个独特的闭包。也就是说，假设您有某种包含值（DOM引用、对象等）的数组，并且设置特定于每个元素的回调时会出现问题，您可以这样做：

var someArray = [ /* whatever */ ];
// ...
someArray.forEach(function(arrayElement) {
  // ... code code code for this one element
  someAsynchronousFunction(arrayElement, function() {
    arrayElement.doSomething();
  });
});

其思想是，与.forEach循环一起使用的回调函数的每次调用都将是其自己的闭包。传递给该处理程序的参数是特定于迭代的特定步骤的数组元素。如果在异步回调中使用它，它不会与在迭代的其他步骤中建立的任何其他回调冲突。

如果您恰好在jQuery中工作，$.each（）函数将为您提供类似的功能。

经典解决方案：封口

您要做的是将每个函数内的变量绑定到函数外的一个单独的不变值：

var函数=[]；函数createfunc（i）{返回函数（）{console.log（“我的值：”+i）；};}对于（变量i=0；i<3；i++）{funcs[i]=创建函数（i）；}对于（变量j=0；j<3；j++）{//现在让我们逐一查看函数[j]（）；}

由于JavaScript中没有块作用域-只有函数作用域-通过将函数创建包装在一个新函数中，可以确保“i”的值保持如预期的那样。

我更喜欢使用forEach函数，它有自己的闭包，可以创建伪范围：

var funcs = [];

new Array(3).fill(0).forEach(function (_, i) { // creating a range
    funcs[i] = function() {            
        // now i is safely incapsulated 
        console.log("My value: " + i);
    };
});

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

这看起来比其他语言的范围更丑陋，但IMHO比其他解决方案更不可怕。

在阅读了各种解决方案之后，我想补充一点，这些解决方案之所以有效，是因为依赖于范围链的概念。这是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的历史！现在，我们可以避免使用箭头函数的块作用域，并使用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</按钮>

下面是一个使用forEach的简单解决方案（可追溯到IE9）：

var函数=[]；[0,1,2].forEach（函数（i）{//让我们创建3个函数funcs[i]=function（）｛//并将它们存储在funcs中console.log（“我的值：”+i）；//每个都应该记录其值。};})对于（变量j=0；j<3；j++）{函数[j]（）；//现在让我们逐一查看}

打印：

我的值：0我的价值：1我的价值：2

这描述了在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);
  }
}

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