var函数=[]；//让我们创建3个函数对于（变量i=0；i<3；i++）{//并将其存储在funcs中funcs[i]=函数（）{//每个都应该记录其值。console.log（“我的值：”，i）；};}对于（变量j=0；j<3；j++）{//现在让我们逐一查看函数[j]（）；}
它输出以下内容：
我的价值：3我的价值：3我的价值：3
而我希望它输出：
我的值：0我的价值：1我的价值：2
当使用事件侦听器导致函数运行延迟时，也会出现同样的问题：
var buttons=document.getElementsByTagName（“button”）；//让我们创建3个函数for（var i=0；i<buttons.length；i++）{//作为事件侦听器buttons[i].addEventListener（“单击”，函数（）{//每个都应该记录其值。console.log（“我的值：”，i）；});}<按钮>0</按钮><br/>＜button＞1＜/button＞<br/><按钮>2</按钮>
…或异步代码，例如使用Promises:
//一些异步等待函数const wait=（ms）=>new Promise（（解析，拒绝）=>setTimeout（解析，ms））；对于（变量i=0；i<3；i++）{//一旦每个承诺得到解决，就记录“i”。等待（i*100）。然后（（）=>console.log（i））；}
在for in和for of循环中也很明显：
常量arr=[1,2,3]；常量fns=[]；用于（arr中的变量i）{fns.push（（）=>console.log（“index:”，i））；}对于（arr的var v）{fns.push（（）=>console.log（“值：”，v））；}for（arr常量）{var obj=｛number：n｝；//或新的MyLibObject（｛…｝）fns.push（（）=>console.log（“n:”，n，“|”，“obj:”，JSON.stringify（obj）））；}for（fns的var f）{f（）；}
这个基本问题的解决方案是什么？
最简单的解决方案是，
而不是使用：
var funcs = [];
for(var i =0; i<3; i++){
funcs[i] = function(){
alert(i);
}
}
for(var j =0; j<3; j++){
funcs[j]();
}
警报“2”3次。这是因为在for循环中创建的匿名函数共享相同的闭包，并且在该闭包中，i的值是相同的。使用此选项可防止共享关闭：
var funcs = [];
for(var new_i =0; new_i<3; new_i++){
(function(i){
funcs[i] = function(){
alert(i);
}
})(new_i);
}
for(var j =0; j<3; j++){
funcs[j]();
}
这背后的想法是，用IIFE（立即调用函数表达式）封装for循环的整个主体，并将new_i作为参数传递，并将其捕获为i。由于匿名函数是立即执行的，因此匿名函数内部定义的每个函数的i值都不同。
此解决方案似乎适合任何此类问题，因为它需要对受此问题困扰的原始代码进行最小的更改。事实上，这是故意的，根本不应该是一个问题！
最简单的解决方案是，
而不是使用：
var funcs = [];
for(var i =0; i<3; i++){
funcs[i] = function(){
alert(i);
}
}
for(var j =0; j<3; j++){
funcs[j]();
}
警报“2”3次。这是因为在for循环中创建的匿名函数共享相同的闭包，并且在该闭包中，i的值是相同的。使用此选项可防止共享关闭：
var funcs = [];
for(var new_i =0; new_i<3; new_i++){
(function(i){
funcs[i] = function(){
alert(i);
}
})(new_i);
}
for(var j =0; j<3; j++){
funcs[j]();
}
这背后的想法是，用IIFE（立即调用函数表达式）封装for循环的整个主体，并将new_i作为参数传递，并将其捕获为i。由于匿名函数是立即执行的，因此匿名函数内部定义的每个函数的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);
}
}
这是因为直接分配了函数范围中的局部变量以及函数参数变量新副本。
