好的。我通读了所有答案。尽管这里有一个很好的解释，但我还是没能让它发挥作用。所以我去上网了。位于的人员https://dzone.com/articles/why-does-javascript-loop-only-use-last-value有一个答案，这里没有给出。所以我想我会发布一个简短的例子。这对我来说更有意义。

长短不一的是，LET命令很好，但现在才被使用。然而，LET命令实际上只是一个TRY-CATCH组合。这一点可以追溯到IE3（我相信）。使用TRY-CATCH组合-生活简单而美好。可能是EMCScript人员决定使用它的原因。它也不需要setTimeout（）函数。所以没有时间浪费。基本上，每个FOR循环需要一个TRY-CATCH组合。下面是一个示例：

    for( var i in myArray ){
       try{ throw i }
       catch(ii){
// Do whatever it is you want to do with ii
          }
       }

如果您有多个FOR循环，只需为每个循环设置一个TRY-CATCH组合。此外，就我个人而言，我总是使用任何FOR变量的双字母。所以“ii”代表“i”等等。我在一个例程中使用这种技术将鼠标悬停命令发送到另一个例程。

首先，了解此代码的错误：

var funcs = [];
for (var 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 (var j = 0; j < 3; j++) {
    funcs[j]();                        // and now let's run each one to see
}

这里，当funcs[]数组初始化时，i递增，funcs数组初始化，func数组的大小变为3，因此i=3，。现在，当调用funcs[j]（）时，它再次使用变量i，变量i已经增加到3。

现在要解决这个问题，我们有很多选择。以下是其中两个：

我们可以用let初始化i，或者用let初始化一个新的变量索引，并使其等于i。因此，当进行调用时，将使用索引，其范围将在初始化后结束。对于调用，索引将再次初始化：var函数=[]；对于（var i=0；i<3；i++）{设索引=i；funcs[i]=函数（）｛console.log（“我的值：”+索引）；};}对于（变量j=0；j<3；j++）{函数[j]（）；}其他选项可以是引入一个返回实际函数的tempFunc：var函数=[]；函数tempFunc（i）{返回函数（）{console.log（“我的值：”+i）；};}对于（var i=0；i<3；i++）{funcs[i]=tempFunc（i）；}对于（变量j=0；j<3；j++）{函数[j]（）；}

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

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

随着ES6现在得到广泛支持，这个问题的最佳答案已经改变。ES6为这种情况提供了let和const关键字。我们可以使用let来设置一个循环范围变量，而不是使用闭包：

var函数=[]；对于（设i=0；i<3；i++）{funcs[i]=函数（）｛console.log（“我的值：”+i）；};}

然后，val将指向一个特定于循环特定转弯的对象，并将返回正确的值，而无需附加闭包符号。这显然大大简化了这个问题。

const类似于let，但有一个额外的限制，即变量名不能在初始赋值后反弹到新引用。

现在，针对最新版本浏览器的浏览器提供了浏览器支持。const/let目前在最新的Firefox、Safari、Edge和Chrome中受支持。Node也支持它，您可以利用Babel等构建工具在任何地方使用它。您可以在这里看到一个工作示例：http://jsfiddle.net/ben336/rbU4t/2/

此处的文档：

常量允许

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

还有另一个解决方案：不要创建另一个循环，只需将this绑定到返回函数。

var函数=[]；函数createFunc（i）{返回函数（）{console.log（'我的值：'+i）//i的对数值。}.调用（this）；}对于（var i=1；i<=5；i++）{//5函数funcs[i]=创建Func（i）；//调用createFunc（）i=5次}

通过绑定它，也解决了问题。

让我们利用新功能。因此，i停止成为闭包的变量，并成为文本的一部分：

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

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