为什么会出现闭包这种东西，解决了什么问题？闭包的理解

本文目录

• 为什么会出现闭包这种东西，解决了什么问题
• 闭包的理解
• 什么是闭包（closure），为什么要用它
• 闭包是什么意思
• 为什么需要闭包闭包是什么概念
• javascript的闭包是什么意思有什么用
• 什么是闭包
• Python基础之闭包
• 闭包的实质是什么
• 闭包的定义是什么

为什么会出现闭包这种东西，解决了什么问题

简单的说闭包是解决了函数内变量暴露给函数外访问
1、就是为了解决突破函数作用域的限制才有了闭包这种概念
2、闭包是一个JavaScript语言中比较难理解并且比较重要的一个知识点

闭包的理解

闭包的理解：闭包就是能够读取其他函数内部变量的函数。

闭包是一种保护私有变量的机制，函数执行时形成私有作用域，保护私有变量不受外界影响。内部函数可以使用外部函数的参数和变量，函数和变量不会被垃圾回收机制回收。

闭包的价值在于可以作为函数对象 或者匿名函数，对于类型系统而言这就意味着不仅要表示数据还要表示代码。支持闭包的多数语言都将函数作为第一级对象，就是说这些函数可以存储到变量中、作为参数传递给其他函数，最重要的是能够被函数动态地创建和返回。

作用是：匿名自执行函数：我们知道所有的变量，如果不加上var关键字，则默认的会添加到全局对象的属性上去，这样的临时变量加入全局对象有很多坏处，如：别的函数可能误用这些变量；造成全局对象过于庞大，影响访问速度(因为变量的取值是需要从原型链上遍历的)。

闭包对页面的影响：

1、防止全局污染。

2、内部的函数可以用外部的变量或参数。

3、内部的变量不会被垃圾回收机制回收。

4、闭包可以更新外部的变量的值。

5、用闭包可以模拟私有方法。

6、由于闭包会使得函数中的变量都被保存在内存中，内存消耗很大，所以不能滥用闭包，否则会造成页面性能的问题；闭包和全局变量一样，如果大量使用可能会造成内存泄漏。

什么是闭包（closure），为什么要用它

闭包指的是一个函数可以访问另一个函数作用域中变量。常见的构造方法，是在一个函数内部定义另外一个函数。内部函数可以引用外层的变量；外层变量不会被垃圾回收机制回收。

注意，闭包的原理是作用域链，所以闭包访问的上级作用域中的变量是个对象，其值为其运算结束后的最后一个值。

优点：避免全局变量污染。缺点：容易造成内存泄漏（变量都被保存在内存中）。

闭包的使用场景：封装组件，函数引用类型，定义私有数据

特性：

a. JavaScript允许你使用在当前函数以外定义的变量

b. 即使外部函数已经返回，当前函数仍然可以引用在外部函数所定义的变量

c. 闭包可以更新外部变量的值

d. 用闭包模拟私有方法

由于闭包会使得函数中的变量都被保存在内存中，内存消耗很大，所以不能滥用闭包，否则会造成网页的性能问题

例子：

闭包是什么意思

闭包意思是指有权访问另一个函数作用域中的变量的函数。

由于在javascript中，只有函数内部的子函数才能读取局部变量，所以说，闭包可以简单理解成“定义在一个函数内部的函数“。

所以，在本质上，闭包是将函数内部和函数外部连接起来的桥梁。

知乎大神说：闭包是指在 JavaScript 中，内部函数总是可以访问其所在的外部函数中声明的参数和变量，即使在其外部函数被返回（寿命终结）了之后。

用途是什么?

1.访问函数内部的变量

2.防止函数内部的变量执行完城后，被销毁，使其一直保存在内存中。

为什么需要闭包闭包是什么概念

闭包的英文对应的是Closure，如果要单纯的讨论这个概念的话就要提到和图灵机起名的大名鼎鼎的lambda演算(lamdba calculus)。尽管lamdba的概念并不是本文的重点，但是闭包概念的目的便是支持lamdba的实现。如果你单独地在百度对进行搜索闭包的话，你会发现大部分都是js相关的内容，主要是js本身就只用闭包的这个概念。但是闭包并不仅限于js，而是一个通用的概念。借用wiki中有点抽象的定义来说的话，闭包就是：

在计算机科学中，闭包（英语：Closure），又称词法闭包（Lexical Closure）或函数闭包（function closures），是引用了自由变量的函数。

简单来说就是当一个方法引用了方法局部变量外的变量时，它就是一个闭包。而如果根据这个定义继续延展的话，就可以得到另外的一种描述方法:

闭包是由函数和与其相关的引用环境（方法外变量）组合而成的实体。

尽管给出了两种关于闭包是什么的定义，但是闭包本身的概念还是较为的抽象。比如直接给例子，我们可以先讨论一下为什么需要闭包。

为了理解闭包，我们可以先假设这样的一种场景:

我有一个方法A，其中有私有变量。我想在别的方法中可以直接访问并使用它，但是又不想直接暴露它。

这时候，就可以在A建立一个内部类B来访问私有变量。那么这时候，这个内部类中你所可以访问B的方法，就和A中的私有变量形成了闭包。此时B已经捕获了A中的变量。即便是A对象销毁了，被B捕获的私有变量仍然不会释放。

所以可以理解，如果希望系统 方法和当前环境的上下文绑定 的话，就可以使用闭包。

尽管有些不恰当，但是我们可以再换一个实际的场景来举个例子帮助你理解：

当你在购物的时候，你选中了一件商品，然后下单。这时候你的订单就已经绑定了你选中的商品。那么你的购买行为就和商品组成了闭包。这时候即便商家下架商品，也不会影响到商品后续的发货签收。并且这些逻辑只需要根据购买行为中的信息进行判断就可以了，而不用关心商家什么时候把商品下架，这写逻辑发生时候的商品价格是什么。

结合上面的例子，我们可以发现，当一个方法和其调用的外部环境形成闭包的时候，由于外部环境已经确定，那么我们就不用再关心外部环境了，而只用关心方法本身。

所以针对我们为什么需要闭包，我给出的答案是:

使用闭包的设计方式，由于闭包本身已经包含了上下文信息，所以可以对北向功能调用（用户）屏蔽由于环境而引发的复杂处理和交互成本。

对于Java来说，可以理解为主要是两种的闭包方式：

其中内部类除了本身的内部类还有局部内部类、匿名内部类。我们以最简洁的匿名内部类来举例：

此时say方法中便捕获了length属性，而如果你使用的是足够版本的IDE的话，获取还会提示你：

Anonymous new ISay() can be replaced with lambda

替换后:

那么这时候你就会发现，此时return的对象就是一个通过匿名后直接描述的函数，而这个函数同时还关联了上下文之外的环境信息。

而在java8中lambda的中我们可以通过函数式编程接口直接接收这种闭包，这些接口常用的为:

关于函数式接口本文就不展开了，但是利用函数式接口，我们就可以这样传递一个闭包：

此时say返回的就不是String的结果了，而是直接将闭包本身返回了。而这个闭包在创建的时候就已经绑定了所需要的环境属性。所以我们可以在需要的时候再调用闭包，并且不用再关心它到底依赖了其他哪些变量:

当然你可能会角色，这个length似乎没有什么用呀，那如果我们换一个形式:

使用Spring的依赖注入后，那么这个Closure类本身可能是各种策略模式策略器中的一个，策略器返回的是一个已经关联了具体策略路由的闭包。而当这个方法提供出去的时候，后续的调用者只需要知道这个闭包是可以针对文本进行处理的就可以，而至于之前是使用的什么策略它则不用关心。因为这些细节都已经通过闭包屏蔽了。

仅仅谈论好的而对问题闭口不谈确实不好，虽然闭包提供了强大的功能，可以对业务细节进行屏蔽，对系统进行接耦拆分。但是闭包本身确实有一些问题需要留意:

可以发现，这两个问题都是由于闭包本身的优点而产生的。由于闭包关联了环境信息，所以其让环境信息中对象的生命周期变长，这对于系统性能的维护以及jvm的垃圾回收都有负面因素。而同时因为不同于一般的编码风格，闭包的使用需要开发人员对实体进行抽象，才能比较好地实现。总结来说，对于开发人员本身有一定要求。

平时我们也经常使用lambda表达式来处理一些业务逻辑，偶尔会出现一下的情况:

先不管这段代码的实现业务背景是什么，但是IDE会提示在userIds.get(i)中的i提示的信息为:

Variable used in lambda expression should be final or effectively final

结合了上文中关于闭包的内容，我们就不难理解。由于闭包是要关联外部环境变量，在这部分代码中关联的是索引变量i，但是因为i本身是局部变量，无法保证关联环境的稳定性（我自己的理解），所以java编译器会强制的要求当闭包关联的是局部变量的时候，需要添加final关键字，而在进行final关键字从而保证该变量的内存引用不会发生改变。从本章的代码上结论上看则是进行了一次内存拷贝，来保证每个闭包中关联的环境变量不会改变，修改后的代码为:

闭包本身是一种面向抽象编程，屏蔽细节的设计原则。在良好的设计下，可以通过闭包来屏蔽对于环境信息的感知，从而简化外部对于系统理解的成本，提高系统的易用性。

javascript的闭包是什么意思有什么用

一、什么是闭包？\x0d\x0a“官方”的解释是：所谓“闭包”，指的是一个拥有许多变量和绑定了这些变量的环境的表达式（通常是一个函数），因而这些变量也是该表达式的一部分。\x0d\x0a相信很少有人能直接看懂这句话，因为他描述的太学术。我想用如何在Javascript中创建一个闭包来告诉你什么是闭包，因为跳过闭包的创建过程直接理解闭包的定义是非常困难的。看下面这段代码： \x0d\x0afunction a(){\x0d\x0a var i=0;\x0d\x0a function b(){\x0d\x0a alert(++i);\x0d\x0a }\x0d\x0a return b;\x0d\x0a}\x0d\x0avar c = a();\x0d\x0ac();\x0d\x0a这段代码有两个特点：\x0d\x0a1、函数b嵌套在函数a内部；\x0d\x0a2、函数a返回函数b。\x0d\x0a这样在执行完var c=a()后，变量c实际上是指向了函数b，再执行c()后就会弹出一个窗口显示i的值(第一次为1)。这段代码其实就创建了一个闭包，为什么？因为函数a外的变量c引用了函数a内的函数b，就是说：\x0d\x0a\x0d\x0a当函数a的内部函数b被函数a外的一个变量引用的时候，就创建了一个闭包。\x0d\x0a\x0d\x0a我猜想你一定还是不理解闭包，因为你不知道闭包有什么作用，下面让我们继续探索。\x0d\x0a\x0d\x0a二、闭包有什么作用？\x0d\x0a简而言之，闭包的作用就是在a执行完并返回后，闭包使得Javascript的垃圾回收机制GC不会收回a所占用的资源，因为a的内部函数b的执行需要依赖a中的变量。这是对闭包作用的非常直白的描述，不专业也不严谨，但大概意思就是这样，理解闭包需要循序渐进的过程。\x0d\x0a在上面的例子中，由于闭包的存在使得函数a返回后，a中的i始终存在，这样每次执行c()，i都是自加1后alert出i的值。\x0d\x0a\x0d\x0a那 么我们来想象另一种情况，如果a返回的不是函数b，情况就完全不同了。因为a执行完后，b没有被返回给a的外界，只是被a所引用，而此时a也只会被b引 用，因此函数a和b互相引用但又不被外界打扰(被外界引用)，函数a和b就会被GC回收。(关于Javascript的垃圾回收机制将在后面详细介绍)\x0d\x0a\x0d\x0a三、闭包内的微观世界\x0d\x0a如 果要更加深入的了解闭包以及函数a和嵌套函数b的关系，我们需要引入另外几个概念：函数的执行环境(excution context)、活动对象(call object)、作用域(scope)、作用域链(scope chain)。以函数a从定义到执行的过程为例阐述这几个概念。\x0d\x0a\x0d\x0a1、当定义函数a的时候，js解释器会将函数a的作用域链(scope chain)设置为定义a时a所在的“环境”，如果a是一个全局函数，则scope chain中只有window对象。\x0d\x0a2、当函数a执行的时候，a会进入相应的执行环境(excution context)。\x0d\x0a3、在创建执行环境的过程中，首先会为a添加一个scope属性，即a的作用域，其值就为第1步中的scope chain。即a.scope=a的作用域链。\x0d\x0a4、然后执行环境会创建一个活动对象(call object)。活动对象也是一个拥有属性的对象，但它不具有原型而且不能通过JavaScript代码直接访问。创建完活动对象后，把活动对象添加到a的作用域链的最顶端。此时a的作用域链包含了两个对象：a的活动对象和window对象。\x0d\x0a5、下一步是在活动对象上添加一个arguments属性，它保存着调用函数a时所传递的参数。\x0d\x0a6、最后把所有函数a的形参和内部的函数b的引用也添加到a的活动对象上。在这一步中，完成了函数b的的定义，因此如同第3步，函数b的作用域链被设置为b所被定义的环境，即a的作用域。\x0d\x0a\x0d\x0a到此，整个函数a从定义到执行的步骤就完成了。此时a返回函数b的引用给c，又函数b的作用域链包含了对函数a的活动对象的引用，也就是说b可以访问到a中定义的所有变量和函数。函数b被c引用，函数b又依赖函数a，因此函数a在返回后不会被GC回收。\x0d\x0a\x0d\x0a当函数b执行的时候亦会像以上步骤一样。因此，执行时b的作用域链包含了3个对象：b的活动对象、a的活动对象和window对象，如下图所示：\x0d\x0a\x0d\x0a如图所示，当在函数b中访问一个变量的时候，搜索顺序是先搜索自身的活动对象，如果存在则返回，如果不存在将继续搜索函数a的活动对象，依 次查找，直到找到为止。如果整个作用域链上都无法找到，则返回undefined。如果函数b存在prototype原型对象，则在查找完自身的活动对象 后先查找自身的原型对象，再继续查找。这就是Javascript中的变量查找机制。\x0d\x0a\x0d\x0a四、闭包的应用场景\x0d\x0a1、保护函数内的变量安全。以最开始的例子为例，函数a中i只有函数b才能访问，而无法通过其他途径访问到，因此保护了i的安全性。\x0d\x0a2、在内存中维持一个变量。依然如前例，由于闭包，函数a中i的一直存在于内存中，因此每次执行c()，都会给i自加1。\x0d\x0a以上两点是闭包最基本的应用场景，很多经典案例都源于此。\x0d\x0a\x0d\x0a五、Javascript的垃圾回收机制\x0d\x0a在Javascript中，如果一个对象不再被引用，那么这个对象就会被GC回收。如果两个对象互相引用，而不再被第3者所引用，那么这两个互相引用的对象也会被回收。因为函数a被b引用，b又被a外的c引用，这就是为什么函数a执行后不会被回收的原因。

什么是闭包

闭包就是能够读取其他函数内部变量的函数。

如在javascript中，只有函数内部的子函数才能读取局部变量，所以闭包可以理解成“定义在一个函数内部的函数“。在本质上，闭包是将函数内部和函数外部连接起来的桥梁。

闭包包含自由（未绑定到特定对象）变量，这些变量不是在这个代码块内或者任何全局上下文中定义的，而是在定义代码块的环境中定义（局部变量）。

“闭包” 一词来源于以下两者的结合：要执行的代码块（由于自由变量被包含在代码块中，这些自由变量以及它们引用的对象没有被释放）和为自由变量提供绑定的计算环境（作用域）。

在PHP、Scala、Scheme、Common Lisp、Smalltalk、Groovy、JavaScript、Ruby、 Python、Go、Lua、objective c、swift 以及Java（Java8及以上）等语言中都能找到对闭包不同程度的支持。

集合 S 是闭集当且仅当 Cl(S)=S（这里的cl即closure，闭包）。特别的，空集的闭包是空集，X 的闭包是 X。集合的交集的闭包总是集合的闭包的交集的子集（不一定是真子集）。有限多个集合的并集的闭包和这些集合的闭包的并集相等；

零个集合的并集为空集，所以这个命题包含了前面的空集的闭包的特殊情况。无限多个集合的并集的闭包不一定等于这些集合的闭包的并集，但前者一定是后者的父集。

Python基础之闭包

一.闭包的定义：

在一个函数的内部，再定义一个函数(内部函数)。这个内部函数引用了外部函数的变量，并且外部函数返回这个内部函数， 我们把这个使用外部函数变量的内部函数称为 闭包 。

简而言之， 闭包就是能够读取外部函数内的变量的函数。

例如：

形成闭包的两个条件:

二.闭包的用途

① 可以读取函数内部的变量

② 将一些变量的值始终保存到内存中

1.读取函数内部的变量

在一般情况下，在函数外部我们是不能访问到函数内部的变量的。但是， 有时想要在函数外部能够访问到函数内部的变量，那么就可以使用闭包。

例如:

上面的代码可以看出，print(a)会抛异常NameError: name ’a’ is not defined。在函数f1的外面无法访问它的变量的。

在函数f1里面定义一个闭包函数就可以访问到了

例如：

2.将一些变量的值始终保存到内存中

运行结果:

通过上面的输出结果可以看出闭包保存了外部函数内的变量n1的值1，每次执行闭包都是在n1 = 1 基础上进行计算的。

三.闭包的缺点

1. 由于闭包会使得函数中的变量都被保存在内存中，会增加 内存消耗 ，所以不能滥用闭包，否则会造成程序的性能问题，可能导致内存泄露

2. 闭包无法改变外部函数局部变量指向的内存地址

3. 返回闭包时，返回函数不要引用任何循环变量，或者后续会发生变化的变量

四.判断一个函数是否是闭包

判断一个函数是不是闭包，可以查看它的 closure 属性。如果该函数是闭包，查看该属性将会返回一个cell对象组成的tuple。如果我们分别对每个cell对象查看其cell_contents属性，返回的内容就是闭包引用的自由变量的值。

运行结果:

闭包的__closure__方法，可以展示出闭包储存了外部函数的两个变量，cell的内存地址是什么，在cell里面储存的对象类型是int，这个int储存的内存地址是什么。

闭包的__closure__方法，可以查看每个cell对象的内容

运行结果:

cell_contents解释了局部变量在脱离函数后仍然可以在函数之外被访问的原因，因为变量被存储在cell_contents中了。

闭包的实质是什么

闭包（closure）是计算机编程领域的专业名词，指可以包含自由（未绑定到特定对象）变量的代码块，子函数可以使用父函数中的局部变量。闭包源于要执行的代码块和为自由变量提供绑定的计算环境（作用域）两者的结合，Scala、Scheme、Common Lisp、Smalltalk、Groovy、JavaScript、Ruby、 Python、Lua、objective c 以及Java（Java8及以上）等语言中都能找到对闭包不同程度的支持。
本质
集合 S 是闭集当且仅当 Cl(S)=S（这里的cl即closure，闭包）。特别的，空集的闭包是空集，X 的闭包是 X。集合的交集的闭包总是集合的闭包的交集的子集（不一定是真子集）。有限多个集合的并集的闭包和这些集合的闭包的并集相等；零个集合的并集为空集，所以这个命题包含了前面的空集的闭包的特殊情况。无限多个集合的并集的闭包不一定等于这些集合的闭包的并集，但前者一定是后者的父集。
若 A 为包含 S 的 X 的子空间，则 S 在 A 中计算得到的闭包等于 A 和 S 在 X 中计算得到的闭包（Cl_A(S) = A ∩ Cl_X(S））的交集。特别的，S在 A 中是稠密的，当且仅当 A 是 Cl_X(S) 的子集。
度量空间中的闭包
对欧几里德空间的子集 S，x 是 S 的闭包点，若所有以 x 为中心的开球都包含 S 的点（这个点也可以是 x）。
这个定义可以推广到度量空间 X 的任意子集 S。具体地说，对具有度量 d 的度量空间 X，x 是 S 的闭包点，若对所有 r》0，存在 y 属于 S，使得距离 d(x,y)《r（同样的，可以是 x = y）。另一种说法可以是，x 是 S 的闭包点，若距离 d(x,S) := inf{d(x,s) : s 属于 S} = 0（这里 inf 表示下确界）。
这个定义也可以推广到拓扑空间，只需要用邻域替代“开球”。设 S 是拓扑空间 X 的子集，则 x 是 S 的闭包点，若所有 x 邻域都包含 S 的点。注意，这个定义并不要求邻域是开的。

闭包的定义是什么

闭包的定义是：

闭包就是能够读取其他函数内部变量的函数。例如在javascript中，只有函数内部的子函数才能读取局部变量，所以闭包可以理解成“定义在一个函数内部的函数“。在本质上，闭包是将函数内部和函数外部连接起来的桥梁。

闭包的本质：

集合 是闭集当且仅当 Cl(S)=S。特别的，空集的闭包是空集，X 的闭包是 X。集合的交集的闭包总是集合的闭包的交集的子集。有限多个集合的并集的闭包和这些集合的闭包的并集相等。

零个集合的并集为空集，所以这个命题包含了前面的空集的闭包的特殊情况。无限多个集合的并集的闭包不一定等于这些集合的闭包的并集，但前者一定是后者的父集。