Javascript 在循环中使用相同的变量来求解；“循环中的闭包”；问题

在问题的继续部分，我尝试了以下代码，在两个循环中使用相同的变量，并得到了期望的结果。我的问题是，为什么

那么初始代码是：

 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]();                      // this will not give desired output
 }

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 ( i = 0; i < 3; i++) {
  funcs[i]();                      // this gives desired output
}

var funcs=[]；
对于（var i=0；i<3；i++）{//让我们创建3个函数
funcs[i]=function（）{//并将它们存储在funcs中
log（“我的值：+i）；//每个都应该记录其值。
};
}
对于（var j=0；j<3；j++）{
funcs[j]（）；//这不会给出所需的输出
}

输出结果如下：

 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]();                      // this will not give desired output
 }

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 ( i = 0; i < 3; i++) {
  funcs[i]();                      // this gives desired output
}

• 我的价值：3
• 我的价值：3
• 我的价值：3

然而，预期输出为：

 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]();                      // this will not give desired output
 }

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 ( i = 0; i < 3; i++) {
  funcs[i]();                      // this gives desired output
}

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

现在，如果我在第二个循环中也使用变量“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]();                      // this will not give desired output
 }

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 ( i = 0; i < 3; i++) {
  funcs[i]();                      // this gives desired output
}

var funcs=[]；
对于（var i=0；i<3；i++）{//让我们创建3个函数
funcs[i]=function（）{//并将它们存储在funcs中
log（“我的值：+i）；//每个都应该记录其值。
};
}
对于（i=0；i<3；i++）{
funcs[i]（）；//这将提供所需的输出
}

我得到了预期的输出

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

---

为什么？

因为变量

i

被污染了。在代码段中，循环写入同一变量

i

，函数读取该变量。请注意，代码中只有一个变量

i

要获得预期结果，您真正需要的是“模块模式”，它包装了一个函数，以在循环中保留变量的本地副本：

for (var i=0; i<3; i++) {
    (function (j) {
        funcs[j] = function() {          // and store them in funcs
            console.log("My value: " + j); // each should log its value.
        };
    })(i);
}

（变量i=0；i）的

现在，如果我在第二个循环中使用变量'I'（一个全局变量）作为
嗯…我得到了预期的输出…为什么

因为在执行第一个执行循环时：

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

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

对于循环的每次迭代，您都为全局变量
i
分配一个新值，
console.log（i）
将记录到控制台：0、1、2

你如何以简单的方式达到预期的效果？
您可以使用
let
以简单的方式实现所需的结果：

"use strict"; // use of let requires strict mode

var funcs = [];

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

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

“使用严格”；//使用let需要严格模式
var funcs=[]；
对于（let i=0；i<3；i++）{//只需在这里用let替换var即可
funcs[i]=函数（）{
console.log（“我的值：+i”）；
};
}
对于（var j=0；j<3；j++）{
funcs[j]（）；
}

现在，数组将由访问局部变量的函数构成，在将函数添加到数组时，局部变量被赋值为
i
。
因为
i
是代码中的全局变量3，它是i的最后一个值，当调用itrewrite时，在for循环之前编写代码声明
var i
一次s-因为这就是您实际正在做的，两个
var i
实际上是相同的
i
-很明显，“循环中的闭包”问题的整个要点是内部函数打印
i
的当前值。如果您将第二个循环更改为例如
for（var i=10；i<13；i++）{
它应该变得更清晰。即使你把
var i
放在全局范围内（至少属于
for
s之外的范围）。试着将每个
for
封装在一个函数中，那么不管你使用什么变量（甚至
i
本身），你都会得到3
3
的结果。