JavaScript闭包如何工作？

1个
2
3
下一个
闭包是以下内容的配对：
一个功能，以及
对函数外部范围的引用（词法环境）
词法环境是每个执行上下文（堆栈框架）的一部分，并且是标识符（即局部变量名称）和值之间的映射。
JavaScript中的每个函数都对其外部词汇环境保持引用。此引用用于配置调用函数时创建的执行上下文。此引用使函数内部的代码可以“查看”在函数外部声明的变量，而不管调用函数的时间和位置。
如果一个函数被一个函数调用，而另一个函数又调用了另一个函数，则将创建对外部词汇环境的引用链。该链称为作用域链。
在以下代码中，inner与调用foo时创建的执行上下文的词法环境形成一个闭包，从而对变量secret进行闭包：
函数foo（）{
const secret = Math.trunc（Math.random（）* 100）
返回函数inner（）{
console.log（`秘密号是$ {secret}。`）
}
}
const f = foo（）//无法从外部`foo`直接访问`secret`
f（）//检索“秘密”的唯一方法是调用“ f”
换句话说：在JavaScript中，函数带有对私有“状态框”的引用，只有它们（以及在相同词法环境中声明的任何其他函数）可以访问。状态框对于函数的调用者是不可见的，从而为数据隐藏和封装提供了出色的机制。
请记住：JavaScript中的函数可以像变量一样传递（一流的函数），这意味着功能和状态对可以在程序中传递：类似于在C ++中传递类实例的方式。
如果JavaScript没有闭包，则必须在函数之间显式传递更多状态，从而使参数列表更长，代码更嘈杂。
因此，如果您希望函数始终有权访问私有状态，则可以使用闭包。
...而且我们经常想将状态与函数关联。例如，在Java或C ++中，当您将私有实例变量和方法添加到类时，您正在将状态与功能相关联。
在C语言和大多数其他常见语言中，函数返回后，所有本地变量将不再可访问，因为堆栈框架被破坏了。在JavaScript中，如果在另一个函数中声明一个函数，则外部函数从其返回后仍可访问。这样，在上面的代码中，机密在从foo返回后仍可用于函数对象内部。
闭包的使用
每当需要与函数关联的私有状态时，闭包都是有用的。这是一种非常常见的情况-请记住：JavaScript直到2015年才使用类语法，并且仍然没有私有字段语法。封闭件可满足此需求。
私有实例变量
在以下代码中，函数toString关闭了汽车的详细信息。
功能Car（制造商，型号，年份，颜色）{
返回{
toString（）{
返回`$ {manufacturer} $ {model}（$ {year}，$ {color}）`
}
}
}
const car = new Car（'Aston Martin'，'V8 Vantage'，'2012'，'Quantum Silver'）
console.log（car.toString（））
功能编程
在下面的代码中，函数inner关闭fn和args。
函数curry（fn）{
const args = []
返回函数inner（arg）{
if（args.length === fn.length）返回fn（... args）
args.push（arg）
返回内部
}
}
函数add（a，b）{
返回a + b
}
const curriedAdd =咖喱（添加）
console.log（curriedAdd（2）（3）（））// 5
面向事件的编程
在以下代码中，函数onClick关闭变量Background_COLOR。
const $ = document.querySelector.bind（文档）
const Background_COLOR ='rgba（200,200,242,1）'
函数onClick（）{
$（'body'）。style.background =背景颜色
}
$（'button'）。addEventListener（'click'，onClick）
设置背景颜色
模块化
在以下示例中，所有实现细节都隐藏在立即执行的函数表达式中。函数tick和toString关闭了它们完成工作所需的私有状态和函数。封闭使我们能够模块化和封装我们的代码。
让命名空间= {};
（函数foo（n）{
让数字= []
函数格式（n）{
返回Math.trunc（n）
}
函数tick（）{
Numbers.push（Math.random（）* 100）
}
函数toString（）{
返回数字。地图（格式）
}
n.counter = {
蜱，
toString
}
}（命名空间））
const counter = namespace.counter
counter.tick（）
counter.tick（）
console.log（counter.toString（））
例子
例子1
此示例显示了局部变量未在闭包中复制：闭包维护对原始变量本身的引用。好像在外部函数之后，堆栈框架仍在内存中保持活动状态退出。
函数foo（）{
令x = 42
让内部=功能（）{console.log（x）}
x = x + 1
返回内部
}
var f = foo（）
f（）//记录43
例子2
在下面的代码中，三种方法在同一词法环境中记录，递增和更新所有关闭。
每次调用createObject时，都会创建一个新的执行上下文（堆栈框架），并创建一个全新的变量x和一组新函数（日志等），它们将覆盖此新变量。
函数createObject（）{
令x = 42;
返回{
log（）{console.log（x）}，
增量（）{x ++}，
更新（值）{x =值}
}
}
const o = createObject（）
o.increment（）
o.log（）// 43
o.update（5）
o.log（）// 5
const p = createObject（）
p.log（）// 42
例子3
如果使用的变量是使用var声明的，请小心了解要关闭的变量。使用var声明的变量被提升。由于引入了let和const，这在现代JavaScript中几乎没有什么问题。
在以下代码中，每次循环时，都会创建一个新的函数inner，该函数在i上关闭。但是因为var i悬挂在循环外部，所以所有这些内部函数都在同一个变量上封闭，这意味着i（3）的最终值被打印了三次。
函数foo（）{
var结果= []
对于（var i = 0; i <3; i ++）{
result.push（function inner（）{console.log（i）}）
}
返回结果
}
const结果= foo（）
//以下内容将打印3次，共3次...
对于（var i = 0; i <3; i ++）{
结果[i]（）
}
最后一点：
每当在JavaScript中声明函数时，都会创建一个闭包。
从另一个函数内部返回一个函数是闭包的经典示例，因为外部函数内部的状态对于返回的内部函数隐式可用，即使在外部函数完成执行之后。
每当在函数内部使用eval（）时，都会使用闭包。您评估的文本可以引用该函数的局部变量，在非严格模式下，您甚至可以使用eval（'var foo =…'）创建新的局部变量。
当您在函数内部使用new Function（…）（函数构造函数）时，它不会关闭其词法环境：而是关闭全局上下文。新函数不能引用外部函数的局部变量。
JavaScript中的闭包就像在函数声明时保留对范围的引用（不是副本），这反过来又保留对其外部范围的引用，依此类推，一直到全局对象的顶部。范围链。
声明函数时创建一个闭包。此关闭用于在调用函数时配置执行上下文。
每次调用函数时都会创建一组新的局部变量。
链接
Douglas Crockford使用闭包为对象模拟了对象的私有属性和私有方法。
如果不小心，闭包将如何导致IE中的内存泄漏的一个很好的解释。
有关JavaScript闭包的MDN文档。
|
JavaScript中的每个函数都维护与其外部词法环境的链接。词汇环境是作用域内所有名称（例如变量，参数）及其值的映射。
因此，每当您看到function关键字时，该函数内部的代码都可以访问在该函数外部声明的变量。
函数foo（x）{
var tmp = 3;
功能栏（y）{
console.log（x + y +（++ tmp））; //将记录16
}
酒吧（10）;
}
foo（2）;
这将记录16，因为功能栏关闭了参数x和变量tmp，这两个参数都存在于外部函数foo的词法环境中。
函数栏及其与函数foo的词法环境的链接都是闭包。
一个函数不必为了创建一个闭包而返回。仅仅凭借其声明，每个函数都会在其封闭的词法环境中关闭，从而形成一个闭合。
函数foo（x）{
var tmp = 3;
返回函数（y）{
console.log（x + y +（++ tmp））; //也将记录16
}
}
var bar = foo（2）;
酒吧（10）; // 16
酒吧（10）; // 17
上面的函数还将记录16，因为bar内的代码仍然可以引用参数x和变量tmp，即使它们不再直接在范围内。
但是，由于tmp仍然在bar的闭包内部徘徊，因此可以将其递增。每次调用bar时，它将增加。
关闭的最简单示例是：
var a = 10;
功能测试（） {
console.log（a）; //将输出10
console.log（b）; //将输出6
}
var b = 6;
测试（）;
调用JavaScript函数时，将创建一个新的执行上下文ec。与函数参数和目标对象一起，此执行上下文还接收到调用执行上下文的词法环境的链接，这意味着可以从以下位置获取在外部词法环境中声明的变量（在上面的示例中，a和b均可用） ec。
每个函数都会创建一个闭包，因为每个函数都有一个到其外部的链接词汇环境。
请注意，变量本身在闭包内部可见，而不是副本。
|
前言：当问题是：
就像老阿尔伯特所说：“如果您不能向六岁的孩子解释它，那么您自己真的不理解。”好吧，我试图向一位27岁的朋友解释JS的关闭，但完全失败了。
任何人都可以认为我6岁并对这个主题感到奇怪吗？
我敢肯定，我是唯一尝试从字面上回答最初问题的人之一。从那时起，这个问题已经改变了几次，所以我的回答现在似乎变得非常愚蠢和不合适。希望这个故事的总体思路对某些人仍然很有趣。
在解释困难的概念时，我非常喜欢类比和隐喻，所以让我尝试一个故事。
很久以前：
有一位公主
函数princess（）{
她生活在一个充满冒险的奇妙世界中。她遇到了白马王子，骑着独角兽环游世界，与巨龙作战，遇到了会说话的动物，以及许多其他奇幻的事物。
var adventures = [];
函数princeCharming（）{/ * ... * /}
var unicorn = {/ * ... * /}，
龙= [/ * ... * /]，
squirrel =“你好！”;
/ * ... * /
但是她总是必须回到繁琐的琐事和大人的世界。
返回{
而且她经常会告诉他们她作为公主的最新奇妙冒险。
故事：function（）{
返回冒险[adventures.length-1];
}
};
}
但是他们只会看到一个小女孩...
var littleGirl = princess（）;
...讲述魔术和幻想的故事
littleGirl.story（）;
即使大人知道真正的公主，他们也永远不会相信独角兽或龙，因为他们永远看不到它们。大人们说，它们只存在于小女孩的想像力之内。
但是我们知道真实的事实；那个里面有公主的小女孩...
...真的是一个公主，里面有一个小女孩。
|
认真对待这个问题，我们应该找出一个典型的6岁孩子在认知上有什么能力，尽管可以承认，对JavaScript感兴趣的人并不那么典型。
关于儿童发展：5至7年：
您的孩子将能够遵循两步指导。例如，如果您对孩子说：“去厨房给我一个垃圾袋”，他们将能够记住该方向。
我们可以使用该示例来说明闭包，如下所示：
厨房是一个封闭的容器，它的局部变量称为rashBags。厨房内部有一个名为getTrashBag的函数，该函数获取一个垃圾袋并返回。
我们可以这样在JavaScript中进行编码：
函数makeKitchen（）{
var trashBags = ['A'，'B'，'C']; //一开始只有3个
返回{
getTrashBag：function（）{
返回trashBags.pop（）;
}
};
}
var kitchen = makeKitchen（）;
console.log（kitchen.getTrashBag（））; //返回垃圾袋C
console.log（kitchen.getTrashBag（））; //返回垃圾袋B
console.log（kitchen.getTrashBag（））; //返回垃圾袋A
进一步说明了为什么闭包有趣的原因：
每次调用makeKitchen（）时，都会使用其自己的单独的rashBags创建一个新的闭包。
trashBags变量是每个厨房内部的局部变量，外部不能访问，但是getTrashBag属性的内部函数可以访问该变量。
每个函数调用都会创建一个闭包，但是除非可以从闭包外部调用可以访问闭包内部的内部函数，否则无需保持闭包。在这里使用getTrashBag函数返回对象。
|
稻草人
我需要知道一个按钮被点击了多少次，并且每三次单击都会执行某项操作...
显而易见的解决方案
//在事件处理程序的范围之外声明计数器
var计数器= 0;
var element = document.getElementById（'button'）;
element.addEventListener（“ click”，function（）{
//外部计数器增加
计数器++;
如果（计数器=== 3）{
//每三次执行一次
console.log（“第三次才是魅力！”）;
//重置计数器
计数器= 0;
}
}）;
点击我！
现在这将起作用，但是它通过添加变量来侵入外部范围，该变量的唯一目的是跟踪计数。在某些情况下，这是可取的，因为您的外部应用程序可能需要访问此信息。但是在这种情况下，我们仅更改每三次单击的行为，因此最好将此功能封装在事件处理程序中。
考虑这个选项
var element = document.getElementById（'button'）;
element.addEventListener（“ click”，（function（）{
//将计数初始化为0
var count = 0;
return function（e）{// <-此函数成为点击处理程序
数++; //并保留对上述`count`的访问权限
如果（count === 3）{
//每三次执行一次
console.log（“第三次才是魅力！”）;
//重置计数器
计数= 0;
}
};
}）（））;
<按钮id =“ button”>点击我！
注意这里的几件事。
在上面的示例中，我正在使用JavaScript的关闭行为。此行为允许任何函数无限期地访问其创建范围。为了实际应用此方法，我立即调用一个返回另一个函数的函数，并且由于我返回的函数可以访问内部count变量（由于上述闭包行为），因此会导致私有范围供结果使用功能...不是那么简单吗？让我们稀释一下...
简单的单行闭包
// _______________________立即调用______________________
// | |
// |保留使用范围___返回____ |
// |仅按返回的函数|功能的价值| |
// | | | | | |
// v v v v v v
var func =（function（）{var a ='val'; return function（）{alert（a）;};}）（）;
返回函数以外的所有变量都可用于返回函数，但不能直接用于返回函数对象...
func（）; //提醒“ val”
func.a; //未定义
得到它？因此，在我们的主要示例中，count变量包含在闭包中，并且始终可供事件处理程序使用，因此它在单击之间保持其状态。
同样，此私有变量状态是完全可访问的，既可用于读取又可分配给其私有范围的变量。
你去了您现在完全封装了此行为。
完整的博客文章（包括jQuery注意事项）
|
闭包很难解释，因为闭包用于使某些行为正常工作，每个人都希望它们能正常工作。我发现解释它们的最佳方法（以及我了解它们的方法）是想象没有它们的情况：
const makePlus = function（x）{
return function（y）{return x + y; };
}
const plus5 = makePlus（5）;
console.log（plus5（3））;
如果JavaScript不知道闭包，在这里会发生什么？只需将最后一行的调用替换为其方法主体（基本上是函数调用所做的工作），您将获得：
console.log（x + 3）;
现在，x的定义在哪里？我们没有在当前范围内对其进行定义。唯一的解决方案是让plus5携带其范围（或更确切地说，其父级的范围）。这样，x定义明确，并绑定到值5。
|
TLDR
闭包是函数与其外部词汇（即，编写的）环境之间的链接，因此，无论何时或从何时，从函数内部都可以看到在该环境中定义的标识符（变量，参数，函数声明等）调用函数的位置。
细节
在ECMAScript规范的术语中，可以说闭包是通过每个功能对象的[[Environment]]引用实现的，该引用指向在其中定义功能的词汇环境。
通过内部[[Call]]方法调用功能时，功能对象上的[[Environment]]引用将复制到新创建的执行上下文（堆栈框架）的环境记录的外部环境引用中。
在以下示例中，函数f关闭了全局执行上下文的词法环境：
函数f（）{}
在下面的示例中，函数h关闭了函数g的词法环境，而后者又关闭了全局执行上下文的词法环境。
函数g（）{
函数h（）{}
}
如果内部函数由外部函数返回，则外部词法环境将在外部函数返回后仍然存在。这是因为如果最终调用内部函数，则外部词汇环境需要可用。
在下面的示例中，函数j关闭了函数i的词法环境，这意味着在函数i完成执行很长时间之后，变量x就可以从函数j内部看到：
函数i（）{
var x ='mochacchino'
返回函数j（）{
console.log（'从函数j：'，x中打印x的值）
}
}
常数k = i（）
setTimeout（k，500）// 500毫秒后调用k（即j）
在闭包中，外部词法环境中的变量本身可用，而不是副本。
函数l（）{
var y ='vanilla';
返回{
setY：函数（值）{
y =值；
}，
logY：函数（值）{
console.log（'y的值为：'，y）;
}
}
}
const o = l（）
o.logY（）// y的值为：vanilla
o.setY（'chocolate'）
o.logY（）// y的值是：Chocolate
通过外部环境引用在执行上下文之间链接的词汇环境链形成了作用域链，并定义了从任何给定函数可见的标识符。
请注意，为了提高清晰度和准确性，这个答案与原始答案有很大的不同。
|
好吧，6岁的瓶盖粉丝。您是否想听到最简单的闭包示例？
让我们想象下一个情况：驾驶员坐在汽车上。那辆车在飞机上。飞机在机场。驾驶员即使在飞机离开机场后也无法进入汽车外部但在飞机内部的东西，这是封闭的。而已。 27岁时，请查看更详细的说明或以下示例。
这是将飞机上的故事转换为代码的方法。
var plane = function（defaultAirport）{
var lastAirportLeft = defaultAirport;
var car = {
司机：{
startAccessPlaneInfo：function（）{
setInterval（function（）{
console.log（“最近的机场是” + lastAirportLeft）;
}，2000年）；
}
}
};
car.driver.startAccessPlaneInfo（）;
返回{
离开机场：函数（airPortName）{
lastAirportLeft = airPortName;
}
}
}（“鲍里斯波尔国际机场”）；
plane.leaveTheAirport（“ John F. Kennedy”）;
|
这是为了消除对其他一些答案中出现的闭包的几种（可能的）误解。
闭包不仅在您返回内部函数时创建。实际上，封闭函数根本不需要返回即可创建封闭函数。您可以改为将内部函数分配给外部作用域中的变量，或者将其作为参数传递给另一个函数，在该函数中可以立即或在以后的任何时间调用它。因此，可能会在调用封闭函数后立即创建封闭函数的关闭，因为只要在调用封闭函数之前或之后，任何内部函数都可以访问该封闭。
闭包在其范围内未引用变量的旧值的副本。变量本身是闭包的一部分，因此访问这些变量之一时看到的值是访问它时的最新值。这就是为什么在循环内部创建内部函数会很棘手的原因，因为每个函数都可以访问相同的外部变量，而不是在创建或调用函数时获取变量的副本。
闭包中的“变量”包括在函数内声明的任何命名函数。它们还包括函数的参数。闭包还可以访问其包含的闭包的变量，直到全局范围为止。
闭包使用内存，但是它们不会导致内存泄漏，因为JavaScript本身会清理自己的未引用的循环结构。当Internet Explorer无法断开引用闭包的DOM属性值时，会引起涉及闭包的Internet Explorer内存泄漏，从而维护对可能为圆形结构的引用。
|
前一段时间，我写了一篇博客文章解释了闭包。这就是我说的关于闭包的原因，因为您想要一个闭包。
闭包是让函数起作用的一种方法
具有持久的私有变量-
也就是说，只有一个变量
函数知道在哪里
跟踪以前的信息
它已经运行了。
从这种意义上讲，它们使函数的行为有点像具有私有属性的对象。
全文：
那么这些关闭的东西是什么呢？
|
闭包很简单：
以下简单示例涵盖了JavaScript闭包的所有要点。*

这是一家生产可以加和乘的计算器的工厂：
函数make_calculator（）{
var n = 0; //此计算器存储单个数字n
返回{
添加：function（a）{
n + = a;
返回n;
}，
乘法：function（a）{
n * = a;
返回n;
}
};
}
first_calculator = make_calculator（）;
second_calculator = make_calculator（）;
first_calculator.add（3）; //返回3
second_calculator.add（400）; //返回400
first_calculator.multiply（11）; //返回33
second_calculator.multiply（10）; //返回4000
关键点：每次对make_calculator的调用都会创建一个新的局部变量n，在make_calculator返回后很长时间，该局部变量n仍可被该计算器的加和乘函数使用。
如果您熟悉堆栈框架，这些计算器似乎很奇怪：make_calculator返回后，它们如何继续访问n？答案是想象JavaScript不使用“堆栈框架”，而是使用“堆框架”，该堆可以在使它们返回的函数调用之后保留。
像add和乘法这样的内部函数，它们访问在外部函数**中声明的变量，称为闭包。
这几乎是闭包的全部内容。
*例如，它涵盖了另一个答案中“封闭的傻瓜”一文中的所有要点，例6除外，该示例仅表明变量可以在声明之前使用，这是一个不错的事实，但与闭合完全无关。它还涵盖了接受的答案中的所有要点，除了以下几点：（1）函数将其参数复制到局部变量（命名的函数参数），以及（2）复制数字创建一个新编号，但是复制对象引用会为您提供对同一对象的另一个引用。这些也是很好知道的，但又与闭包完全无关。它也与该答案中的示例非常相似，但更简短，更抽象。它没有涵盖此答案或注释的要点，这是因为JavaScript使得很难将循环变量的当前值插入到您的内部函数中：“插入”步骤只能由包含辅助函数的函数来完成您的内部函数，并在每次循环迭代时调用。 （严格来说，内部函数访问变量的帮助函数的副本，而不是插入任何内容。）再次，这在创建闭包时非常有用，但不是闭包的一部分或工作方式的一部分。由于闭包在ML之类的功能语言中的工作方式不同，还存在其他混淆，其中变量绑定到值而不是存储空间，从而提供了源源不断的了解闭包的人（即“插入”方式），即对于JavaScript而言，这是完全不正确的，因为JavaScript始终将变量绑定到存储空间，而不绑定到值。
**任何外部函数（如果有多个嵌套函数，甚至在全局上下文中），正如该答案所明确指出的那样。
|
我如何向六岁的孩子解释：
您知道大人如何拥有房屋，他们称之为房屋吗？当妈妈有孩子时，孩子实际上并不拥有任何东西，对吗？但是它的父母拥有一所房子，因此只要有人问孩子“你的房子在哪里？”，他/她就可以回答“那所房子！”，并指向其父母的房子。 “关闭”是指孩子始终（即使在国外）也能够说自己有住房的能力，即使实际上是父母拥有房屋。
|
您能向5岁的孩子解释关闭吗？*
我仍然认为Google的解释非常有效且简洁：
/ *
*当一个函数在另一个函数中定义并且
*即使在之后也可以访问外部函数的上下文
*外部函数返回。
*
*使用JavaScript学习的重要概念。
* /
函数externalFunction（someNum）{
var someString ='嘿！';
var content = document.getElementById（'content'）;
函数innerFunction（）{
content.innerHTML = someNum +'：'+ someString;
内容= null; // Internet Explorer内存泄漏以供DOM参考
}
innerFunction（）;
}
outsideFunction（1）;.
*一个C＃问题
|
通过GOOD / BAD比较，我倾向于学得更好。我喜欢看到有人可能会遇到的工作代码，然后是非工作代码。我整理了一个jsFiddle进行比较，并尝试将差异归结为我能想到的最简单的解释。
关闭正确：
console.log（'CLOSURES DONE RIGHT''）;
var arr = [];
函数createClosure（n）{
返回函数（）{
返回'n ='+ n;
}
}
for（var index = 0; index <10; index ++）{
arr [index] = createClosure（index）;
}
for（arr中的var index）{
console.log（arr [index]（））;
}
在上面的代码中，循环的每次迭代都调用createClosure（n）。请注意，我将变量n命名为突出显示它是在新函数作用域中创建的新变量，而不是与绑定到外部作用域的index相同的变量。
这将创建一个新范围，并且n绑定到该范围；这意味着我们有10个单独的范围，每个迭代一个。
createClosure（n）返回一个函数，该函数返回该范围内的n。
在每个范围内，n绑定到调用createClosure（n）时具有的任何值，因此要返回的嵌套函数将始终返回调用createClosure（n）时具有的n的值。
关闭做错了：
console.log（'CLOSURES DONE WRONG'）;
函数createClosureArray（）{
var badArr = [];
for（var index = 0; index <10; index ++）{
badArr [index] = function（）{
返回'n ='+索引；
};
}
返回badArr;
}
var badArr = createClosureArray（）;
for（badArr中的var index）{
console.log（badArr [index]（））;
}
在上面的代码中，循环在createClosureArray（）函数中移动，该函数现在仅返回完整的数组，乍一看似乎更直观。
可能不明显的是，由于仅调用一次createClosureArray（）才能为此函数创建一个作用域，而不是每次循环都创建一个作用域。
在此函数中，定义了一个名为index的变量。循环运行并将函数添加到返回索引的数组中。请注意，索引是在createClosureArray函数中定义的，该函数只能被调用一次。
由于createClosureArray（）函数中只有一个作用域，因此index仅绑定到该范围内的一个值。换句话说，每次循环更改index的值时，都会为该范围内引用它的所有内容更改它。
添加到数组的所有函数都从定义它的父作用域返回SAME索引变量而不是像第一个示例那样来自10个不同范围的10个不同示波器。最终结果是所有10个函数都从同一作用域返回相同的变量。
循环结束并完成索引修改后，最终值为10，因此，添加到数组的每个函数都将返回单个索引变量的值，该值现在设置为10。
结果
正确关闭
n = 0
n = 1
n = 2
n = 3
n = 4
n = 5
n = 6
n = 7
n = 8
n = 9
关闭错误
n = 10
n = 10
n = 10
n = 10
n = 10
n = 10
n = 10
n = 10
n = 10
n = 10
|
关于关闭的维基百科：
在计算机科学中，闭包是一个函数，以及对该函数的非本地名称（自由变量）的引用环境。
从技术上讲，在JavaScript中，每个函数都是闭包。它始终可以访问在周围范围内定义的变量。
由于JavaScript中的作用域定义构造是一个函数，而不是像许多其他语言中的代码块那样，因此JavaScript中闭包通常指的是一个函数，该函数使用已执行的周围函数中定义的非局部变量。
闭包通常用于创建具有一些隐藏的私有数据的函数（但并非总是如此）。
var db =（function（）{
//创建一个隐藏的对象，它将保存数据
//从外部无法访问。
var data = {};
//创建一个函数，它将提供对数据的一些访问。
返回函数（键，值）{
if（val === undefined）{return data [key]} //获取
else {return data [key] = val} //设置
}
//我们正在调用匿名的周围函数，
//返回上面的内部函数，它是一个闭包。
}）（）;
db（'x'）//->未定义
db（'x'，1）//将x设置为1
db（'x'）//-> 1
//无法访问数据对象本身。
//我们可以获取或设置它。
EMS
上面的示例使用一个匿名函数，该函数执行一次。但这不是必须的。可以命名它（例如mkdb）并在以后执行，每次调用它都会生成一个数据库函数。每个生成的函数将具有其自己的隐藏数据库对象。闭包的另一个用法示例是当我们不返回一个函数，而是一个对象，该对象包含出于不同目的的多个函数，这些函数中的每个函数都可以访问相同的数据。
|
我整理了一个交互式JavaScript教程，以解释闭包是如何工作的。
什么是封包？
这是示例之一：
var create = function（x）{
var f = function（）{
返回x; //我们可以在这里引用x！
};
返回f;
};
//'create'接受一个参数，创建一个函数
var g = create（42）;
// g是一个现在不带参数的函数
var y = g（）;
//此处的y为42
|
孩子们将永远记住与父母分享的秘密，即使父母已经
没了这就是函数的闭包。
JavaScript函数的秘密是私有变量
var parent = function（）{
var name =“ Mary”; //秘密
}
每次调用它时，都会创建局部变量“ name”，并给定名称“ Mary”。并且每次函数退出时，变量都会丢失并且名称会被忘记。
您可能会猜到，因为每次调用函数时都会重新创建变量，并且没人会知道它们，所以必须在一个秘密的地方存储它们。它可以称为“密室”或“堆栈”或“本地范围”，但这并不重要。我们知道它们在那里，藏在内存中。
但是，在JavaScript中，有一个非常特殊的东西，即在其他函数内部创建的函数也可以知道其父级的局部变量，并在它们存在之前一直保留它们。
var parent = function（）{
var name =“ Mary”;
var child = function（childName）{
//我也看到“ name”是“ Mary”
}
}
因此，只要我们在父函数中，它就可以创建一个或多个子函数，这些子函数确实共享秘密位置的秘密变量。
但是，令人遗憾的是，如果子项也是其父函数的私有变量，则在父项结束时它也会死亡，而秘密也会随之消失。
为了生存，孩子必须在为时已晚之前离开
var parent = function（）{
var name =“ Mary”;
var child = function（childName）{
返回“我的名字是“ + childName +”，孩子是“ + name”；
}
归还孩子//孩子离开父母->
}
var child = parent（）; // <-在这里
现在，即使玛丽“不再跑步”，她的记忆也不会丢失，她的孩子将永远记住她的名字和他们在一起时分享的其他秘密。
因此，如果您称孩子“爱丽丝”，她会回应
child（“ Alice”）=>“我叫爱丽丝，玛丽的孩子”
这就是全部。
|
我不明白为什么答案在这里这么复杂。
这是一个闭包：
var a = 42;
函数b（）{返回a; }
是。您可能一天使用多次。
没有理由相信闭包是要解决的复杂设计问题具体问题。不，从函数声明的位置（不运行）的角度来看，闭包只是使用来自更高范围的变量。
现在，它允许您执行的操作会更加壮观，请参阅其他答案。
|
dlaliberte第一点的示例：
闭包不仅在您返回内部函数时创建。实际上，封闭函数根本不需要返回。您可以改为将内部函数分配给外部作用域中的变量，或将其作为参数传递给可以立即使用的另一个函数。因此，由于在调用任何内部函数后都可以访问该封闭函数，因此封闭函数的关闭可能已经存在。
var i;
函数foo（x）{
var tmp = 3;
i =函数（y）{
console.log（x + y +（++ tmp））;
}
}
foo（2）;
i（3）;
|
闭包是内部函数可以访问其外部函数中的变量的地方。这可能是闭包最简单的单行解释。
|
我知道已经有很多解决方案，但是我猜想这个小而简单的脚本可以用来说明这个概念：
// makeSequencer将返回一个“ sequencer”函数
var makeSequencer = function（）{
var _count = 0; //无法在此函数之外访问
var sequencer = function（）{
返回_count ++;
}
返回音序器；
}
var fnext = makeSequencer（）;
var v0 = fnext（）; // v0 = 0;
var v1 = fnext（）; // v1 = 1;
var vz = fnext._count // vz =未定义
|
您正在睡觉，请Dan。
您告诉Dan带一个XBox控制器。
丹邀请保罗。
丹请保罗带一名管制员。有多少控制者参加了聚会？
function sleepOver（howManyControllersToBring）{
var numberOfDansControllers = howManyControllersToBring;
返回函数danInvitedPaul（numberOfPaulsControllers）{
var totalControllers = numberOfDansControllers + numberOfPaulsControllers;
返回totalControllers;
}
}
var howManyControllersToBring = 1;
var InvitationDan = sleepOver（howManyControllersToBring）;
// Paul被邀请的唯一原因是Dan被邀请。
//因此，我们设置了Paul的邀请= Dan的邀请。
var danInvitedPaul = InvitationDan（howManyControllersToBring）;
alert（“有” + danInvitedPaul +“控制器被带到了聚会。”）;
|
Closures的作者很好地解释了闭包，解释了我们为什么需要它们的原因，还解释了LexicalEnvironment，这对于理解闭包是必需的。
这是摘要：
如果访问了变量但不是局部变量怎么办？像这儿：
在这种情况下，解释器会在
外部LexicalEnvironment对象。
该过程包括两个步骤：
首先，创建函数f时，不要将其创建为空
空间。当前有一个LexicalEnvironment对象。在这种情况下
上面是窗口（功能启用时未定义
创建）。
创建函数时，它将获得一个名为[[Scope]]的隐藏属性，该属性引用当前的LexicalEnvironment。
如果读取了变量，但在任何地方都找不到，则会生成错误。
嵌套函数
函数可以彼此嵌套，形成LexicalEnvironments链，也可以称为作用域链。
因此，函数g可以访问g，a和f。
关闭
外部函数完成后，嵌套函数可能会继续存在：
标记词法环境：
如我们所见，this.say是用户对象中的一个属性，因此它在用户完成后继续存在。
并且，如果您还记得，在创建this.say时，它（作为每个函数）将获得内部this.say。[[Scope]]对当前LexicalEnvironment的内部引用。因此，当前用户执行的LexicalEnvironment保留在内存中。 User的所有变量也都是其属性，因此也要小心保留它们，而不是像往常一样使用。
关键是要确保内部函数将来要访问外部变量，它能够这样做。
总结一下：
内部函数保留对外部函数的引用
词法环境。
内部函数可以从中访问变量
即使外部功能完成也可以。
浏览器将LexicalEnvironment及其所有属性（变量）保留在内存中，直到有一个内部函数引用它为止。
这称为关闭。
|
JavaScript函数可以访问它们：
争论
局部变量（即它们的局部变量和局部函数）
环境，包括：
全球，包括DOM
外部功能中的任何东西
如果函数访问其环境，则该函数为闭包。
注意，外部函数不是必需的，尽管它们确实提供了好处，我在这里不讨论。通过访问其环境中的数据，闭包可以使该数据保持活动状态。在外部/内部函数的子情况下，外部函数可以创建本地数据并最终退出，但是如果有内部函数函数在外部函数退出后仍然存在，然后内部函数使外部函数的本地数据保持活动状态。
使用全局环境的闭包示例：
想象一下，堆栈溢出投票和投票按下按钮事件是作为闭包，votUp_click和voteDown_click实现的，它们可以访问全局定义的外部变量isVotedUp和isVotedDown。 （为简单起见，我指的是StackOverflow的“问题投票”按钮，而不是“答案投票”按钮的数组。）
当用户单击VoteUp按钮时，voteUp_click函数将检查isVotedDown == true，以确定是投票还是只取消反对票。函数votUp_click是一个闭包，因为它正在访问其环境。
var isVotedUp = false;
var isVotedDown = false;
函数votUp_click（）{
如果（isVotedUp）
返回;
否则（isVotedDown）
SetDownVote（false）;
其他
SetUpVote（true）;
}
函数votDown_click（）{
如果（isVotedDown）
返回;
否则（isVotedUp）
SetUpVote（false）;
其他
SetDownVote（true）;
}
函数SetUpVote（状态）{
isVotedUp =状态；
//对“投票”按钮做一些CSS的工作
}
函数SetDownVote（status）{
isVotedDown =状态；
//对“投票”按钮进行一些CSS处理
}
所有这四个功能都是闭包，因为它们都访问环境。
|
作为一个现年6岁的孩子的父亲，他目前正在教幼儿（并且是一个相对新手，没有正规教育的编码，因此需要更正），我认为该课程将通过动手游戏保持最佳状态。如果6岁的孩子准备好了解什么是封闭，那么他们已经足够大了，可以自己去做。我建议将代码粘贴到jsfiddle.net中，进行一些解释，并让他们独自编写一首独特的歌曲。下面的解释性文字可能更适合10岁以下的儿童。
功能sing（person）{
var firstPart =“有人吞下了” +人+“；
var fly = function（）{
var生物=“苍蝇”；
var result =“也许她会死”；
alert（firstPart +生物+“ \ n” +结果）;
};
var spider = function（）{
var生物=“蜘蛛”；
var result =“在她体内摇摆不定的东西”
alert（firstPart +生物+“ \ n” +结果）;
};
var bird = function（）{
var生物=“一只鸟”;
var result =“多么荒谬！”;
alert（firstPart +生物+“ \ n” +结果）;
};
var cat = function（）{
var生物=“一只猫”;
var result =“想象一下！”;
alert（firstPart +生物+“ \ n” +结果）;
};
飞（）;
蜘蛛（）;
鸟（）;
猫（）;
}
var person =“ an old lady”;
唱（人）；
使用说明
数据：数据是事实的集合。它可以是数字，单词，量度，观察值，甚至只是事物的描述。您不能触摸，闻到或尝尝它。您可以写下来，说出来并听到。您可以使用它在计算机上产生触摸气味和味道。计算机可以使用代码使它变得有用。
代码：以上所有文字称为代码。它是用JavaScript编写的。
JAVASCRIPT：JavaScript是一种语言。像英语或法语或中文都是语言。计算机和其他电子处理器可以理解许多语言。为了使JavaScript能够被计算机理解，它需要一个解释器。想象一下，如果一位只会说俄语的老师来学校教您的课程。当老师说“всесадятся”时，全班听不懂。但是幸运的是，您的班上有一个俄罗斯学生，他告诉每个人这意味着“每个人都坐下”-你们都一样。全班就像一台电脑，俄语学生是口译员。对于JavaScript，最常见的解释器称为浏览器。
浏览器：当您通过计算机，平板电脑或手机上的Internet连接访问网站时，便使用了浏览器。您可能知道的示例是Internet Explorer，Chrome，Firefox和Safari。浏览器可以理解JavaScript并告诉计算机它需要做什么。 JavaScript指令称为函数。
功能：JavaScript中的函数就像一个工厂。这可能是一个只有一台机器的小工厂。或者它可能包含其他许多小工厂，每个工厂都有许多从事不同工作的机器。在现实生活中的服装工厂中，可能会有成堆的布料和线筒进来，而T恤和牛仔裤就出来了。我们的JavaScript工厂仅处理数据，无法缝制，钻孔或熔化金属。在我们的JavaScript工厂中，数据进入并且数据出来。
所有这些数据听起来都有些无聊，但确实非常酷。我们可能有一个告诉机器人晚餐要做什么的功能。假设我邀请您和您的朋友来我家。您最喜欢鸡腿，我喜欢香肠，您的朋友总是想要您想要的东西，而我的朋友不吃肉。
我没有时间去购物，因此该功能需要知道我们在冰箱中的存货才能做出决定。每种食材都有不同的烹饪时间，我们希望一切都变得同时由机器人提供服务。我们需要向功能提供所需数据，功能可以与冰箱“对话”，并且功能可以控制机器人。
函数通常具有名称，括号和花括号。像这样：
函数cookMeal（）{/ *函数内的文件* /}
请注意，/ * ... * /和//停止代码被浏览器读取。
NAME：您可以随便使用一个单词就可以调用一个函数。示例“ cookMeal”通常将两个单词连接在一起，并在第二个单词开头加一个大写字母-但这不是必需的。它不能有空格，也不能单独是数字。
家长：“括号”或（）是JavaScript函数工厂门上的信箱或街道上用于向工厂发送信息包的信箱。有时可能会标记邮箱，例如cookMeal（您，我，yourFriend，myFriend，冰箱，diningTime），在这种情况下，您知道必须提供哪些数据。
大括号：看起来像{}的“括号”是我们工厂的有色窗户。从工厂内部可以看到，但是从外部看不到。
上面的长代码示例
我们的代码以单词function开头，因此我们知道它是其中之一！然后，函数的名称会唱歌-这是我对函数含义的描述。然后括号（）。括号总是存在于函数中。有时他们是空的，有时他们里面有东西。这个人的名字是：（人）。在这之后有一个这样的括号{。这标志着函数sing（）的开始。它有一个标记sing（）结束的伙伴，例如}
函数sing（person）{/ *函数内的文件* /}
因此，此功能可能与唱歌有关，并且可能需要有关某个人的一些数据。它内部有指令来处理这些数据。
现在，在函数sing（）之后，代码的结尾处是该行
var person =“ an old lady”;
变量：字母var代表“变量”。变量就像一个信封。在外面的信封上标有“人”字样。它的内部包含一张纸条，上面有我们的功能所需的信息，一些字母和空格像一条绳子（称为绳子）连接在一起，构成一个短语，上面写着“一位老太太”。我们的信封可能包含其他种类的东西，例如数字（称为整数），指令（称为函数），列表（称为数组）。因为此变量写在所有大括号{}的外面，并且当您在大括号内时可以通过着色窗口看到，所以可以在代码的任何位置看到此变量。我们称其为“全局变量”。
全局变量：person是一个全局变量，这意味着如果您将其值从“老太太”更改为“年轻人”，则该人将一直是年轻人，直到您决定再次更改它，并且其他任何功能代码可以看到这是一个年轻人。按F12按钮或查看“选项”设置以打开浏览器的开发人员控制台，然后键入“ person”以查看该值是什么。键入person =“ a young man”进行更改，然后再次键入“ person”以查看其已更改。
在此之后，我们有线
唱（人）；
该行正在调用函数，就好像它在调用狗一样
“唱吧，来吧！”
当浏览器加载JavaScript代码并到达此行时，它将启动该功能。我将这一行放在最后，以确保浏览器具有运行它所需的所有信息。
功能定义动作-主要功能是唱歌。它包含一个名为firstPart的变量，该变量适用于歌唱每首歌的人的歌唱：“有“ +人+谁吞了”。如果在控制台中键入firstPart，则不会得到答案，因为该变量已锁定在函数中-浏览器无法在花括号的着色窗口内看到。
关闭：关闭是在sing（）函数内部的较小函数。大工厂里面的小工厂。它们每个都有自己的大括号，这意味着它们的变量无法从外部看到。这就是为什么变量名（生物和结果）可以在闭包中重复但值不同的原因。如果在控制台窗口中键入这些变量名，则不会得到它的值，因为它被两层着色窗口隐藏了。
闭包都知道sing（）函数名为firstPart的变量是什么，因为它们可以从其着色窗口中看到。
封闭之后，线路
飞（）;
蜘蛛（）;
鸟（）;
猫（）;
sing（）函数将按照给定的顺序调用这些函数。然后sing（）函数的工作将完成。
|
好吧，和一个6岁的孩子聊天，我可能会使用以下关联。
想象-您正在玩自己的游戏整个房子里的小兄弟姐妹，您正带着玩具四处走动，并将其中一些带入哥哥的房间。一段时间后，您的兄弟从学校返回并去了他的房间，他锁在房间里，所以现在您不能再直接访问那里剩下的玩具了。但是你可以敲门，问你的兄弟那个玩具。这称为玩具的闭合；您的兄弟为您做了补偿，现在他已经进入了外部视野。
与之相比，情况是一扇门被通风装置锁住，里面没有人（执行常规功能），然后发生局部火灾并烧毁了房间（垃圾收集器：D），然后建造了一个新房间，现在您可以离开了那里有另一个玩具（新功能实例），但从未获得与第一个房间实例中剩余的玩具相同的玩具。
对于高龄儿童，我会输入以下内容。它不是完美的，但是会让您感觉到它是什么：
函数playInBrothersRoom（withToys）{
//我们关闭在哥哥房间玩的玩具。当他回来锁门时
//您的兄弟现在应该进入外部[[scope]]对象。谢谢上帝，你可以和他沟通。
varclosureToys = withToys || []，
returnToy，countIt，玩具； //只是另一个关闭助手，供兄弟内部使用。
var brotherGivesToyBack =函数（玩具）{
//新请求。兄弟的手还没有闭塞玩具。给他一点时间。
returnToy = null;
if（toy && closureToys.length> 0）{//如果我们要一个特定的玩具，兄弟会去寻找它。
for（countIt = ClosureToys.length; countIt; countIt--）{
如果（closureToys [countIt-1] ==玩具）{
returnToy ='带上你的'+ closureToys.splice（countIt-1，1）+'，小男孩！';
打破;
}
}
returnToy = returnToy || “嘿，我在这里找不到任何'+玩具+'。在另一个房间里寻找它。
}
否则if（closureToys.length> 0）{//否则，就把他房间里的所有东西都还给他。
returnToy ='瞧！ '+ closureToys.join（'，'）+'。';
ClosureToys = [];
}
其他{
returnToy ='嘿，小虾，我给了你一切！';
}
console.log（returnToy）;
}
返回brotherGivesToyBack;
}
//您正在房子里玩，包括兄弟的房间。
var toys = ['teddybear'，'car'，'jumpingrope']，
askBrotherForClosuredToy = playingInBrothersRoom（toys）;
//门被锁上了，兄弟从学校来了。您无法作弊并直接将其取出。
console.log（askBrotherForClosuredToy.closureToys）; //未定义
//但是您可以礼貌地请您兄弟退还给您。
askBrotherForClosuredToy（'teddybear'）; //哇，这是teddybear
askBrotherForClosuredToy（'ball'）; //兄弟将找不到它。
askBrotherForClosuredToy（）; //兄弟给你剩下的一切
askBrotherForClosuredToy（）; //那里什么也没有
如您所见，无论房间是否上锁，仍然可以通过兄弟访问留在房间里的玩具。这是一个可玩的jsbin。
|
一个六岁孩子的答案（假设他知道什么是函数，什么是变量以及什么数据）：
函数可以返回数据。您可以从函数返回的一种数据是另一种函数。当返回该新函数时，创建该函数的函数中使用的所有变量和参数都不会消失。而是，该父函数“关闭”。换句话说，除了返回的功能外，什么都看不到它，也看不到它使用的变量。该新函数具有特殊的功能，可以回顾创建它的函数内部并查看其中的数据。
函数the_closure（）{
var x = 4;
返回函数（）{
返回x; //在这里，我们在the_closure内部查看x的值
}
}
var myFn = the_closure（）;
myFn（）; // => 4
解释它的另一种非常简单的方法是在范围方面：
每当您在较大范围内创建较小范围时，较小范围将始终能够看到较大范围中的内容。
|
JavaScript中的函数不仅是对一组指令的引用（如C语言），而且还包含一个隐藏的数据结构，该结构由对其使用的所有非局部变量（捕获的变量）的引用组成。这种两件式功能称为闭包。 JavaScript中的每个函数都可以视为闭包。
闭包是具有状态的函数。从某种意义上说，它与“ this”类似，因为“ this”还提供了函数的状态，但是function和“ this”是单独的对象（“ this”只是一个奇特的参数，是将其永久绑定到功能是创建一个闭包）。尽管“ this”和函数始终是分开存在的，但不能将函数与其闭包分开，并且语言不提供访问捕获变量的方法。
因为词汇嵌套函数引用的所有这些外部变量实际上是其词汇包围链中的局部变量函数（可以将全局变量假定为某个根函数的局部变量），并且函数的每次执行都会创建其局部变量的新实例，因此，函数的每次执行都会返回（或以其他方式将其移出，例如将其注册为回调），嵌套函数将创建一个新的闭包（具有其自身可能唯一的一组引用非本地变量，这些变量代表其执行上下文）。
另外，必须理解，JavaScript中的局部变量不是在堆栈框架上创建的，而是在堆上创建的，并且仅在没有人引用它们时才销毁。当函数返回时，对其局部变量的引用会递减，但如果它们在当前执行期间成为闭包的一部分，并且仍由其词法嵌套函数引用（它们仅在引用时有效），它们仍然可以为非空。这些嵌套函数被返回或以其他方式转移到某些外部代码）。
一个例子：
函数foo（initValue）{
//当foo函数退出时，此变量不会被破坏。
//它被下面返回的两个嵌套函数“捕获”。
var value = initValue;
//请注意，两个返回的函数是立即创建的。
//如果再次调用foo函数，它将返回
//引用不同“值”变量的新函数。
返回{
getValue：function（）{返回值； }，
setValue：function（newValue）{value = newValue; }
}
}
功能栏（）{
// foo将其本地变量“值”设置为5并返回一个对象
//两个函数仍引用该局部变量
var obj = foo（5）;
//提取函数只是为了表明此处不涉及“ this”
var getValue = obj.getValue;
var setValue = obj.setValue;
alert（getValue（））; //显示5
setValue（10）;
alert（getValue（））; //显示10
//此时getValue和setValue函数已销毁
//（实际上，它们在垃圾回收器的下一次迭代中被销毁）。
// foo中的局部变量“ value”不再被引用
//任何东西也被破坏了。
}
酒吧（）;
|
也许除了六岁孩子中最早熟的孩子之外，它可能有点超出所有人，但是一些帮助使JavaScript中的闭包概念成为我的例子。
闭包是可以访问另一个函数的作用域（其变量和函数）的函数。创建闭包的最简单方法是在函数内使用一个函数。原因是在JavaScript中，函数始终可以访问其包含函数的作用域。
函数externalFunction（）{
var externalVar =“猴子”;
函数innerFunction（）{
警报（outerVar）;
}
innerFunction（）;
}
outsideFunction（）;
警报：猴子
在上面的示例中，调用了externalFunction，依次调用了innerFunction。请注意，innerFunction如何使用outerVar，这可以通过正确警告outerVar的值来证明。
现在考虑以下几点：
函数externalFunction（）{
var externalVar =“猴子”;
函数innerFunction（）{
返回externalVar;
}
返回innerFunction;
}
var referenceToInnerFunction = externalFunction（）;
alert（referenceToInnerFunction（））;
警报：猴子
referenceToInnerFunction设置为outerFunction（），它仅返回对innerFunction的引用。调用referenceToInnerFunction时，它将返回outerVar。再次，如上所述，这证明了innerFunction可以访问outsideVar（outerFunction的变量）。此外，有趣的是，即使在externalFunction完成执行后，它仍保留该访问权限。
在这里，事情变得非常有趣。如果要摆脱outerFunction，例如将其设置为null，您可能会认为referenceToInnerFunction将失去对outerVar值的访问。但这种情况并非如此。
函数externalFunction（）{
var externalVar =“猴子”;
函数innerFunction（）{
返回externalVar;
}
返回innerFunction;
}
var referenceToInnerFunction = externalFunction（）;
alert（referenceToInnerFunction（））;
outsideFunction = null;
alert（referenceToInnerFunction（））;
警报：猴子
警报：猴子
但是怎么回事？既然将outerFunction设置为null，referenceToInnerFunction仍如何知道outerVar的值？
referenceToInnerFunction仍然可以访问outerVar的值的原因是，当通过将innerFunction放置在outerFunction的内部来首次创建闭包时，innerFunction在其作用域链中添加了对outerFunction的作用域（变量和函数）的引用。这意味着innerFunction拥有指向或指向所有externalFunction变量（包括externalVar）的引用。因此，即使outerFunction完成执行，或者即使将其删除或设置为null，其范围内的变量（例如outerVar）也会在内存中停留，因为在internalFunction部分上对它们的出色引用referenceToInnerFunction。真正从中释放outerVar和其余outerFunction的变量内存中，您必须摆脱对它们的突出引用，例如通过将referenceToInnerFunction设置为null。
//////////
关于闭包要注意的另外两件事。首先，闭包将始终可以访问其包含函数的最后一个值。
函数externalFunction（）{
var externalVar =“猴子”;
函数innerFunction（）{
警报（outerVar）;
}
outsideVar =“大猩猩”;
innerFunction（）;
}
outsideFunction（）;
警报：大猩猩
其次，在创建闭包时，它会保留对其所有封闭函数的变量和函数的引用；它不是可以选择的。但是，因此，应该谨慎使用闭包，或者至少要小心使用闭包，因为它们可能占用大量内存；在包含函数执行完毕后很长一段时间内，许多变量可以保留在内存中。
|
我只是将它们指向Mozilla Closures页面。这是我发现的关于闭包基础知识和实际用法的最佳，最简洁明了的解释。强烈建议任何学习JavaScript的人使用。
是的，我什至推荐给6岁的孩子使用-如果6岁的孩子正在学习闭包，那么可以随时理解本文提供的简洁明了的逻辑是合乎逻辑的。
|
1个
2
3
下一个
不是您要找的答案？浏览标记有javascript函数变量范围闭包的其他问题，或提出您自己的问题。