1、为什么会有闭包
 
 
 
由于作用域的原因，我们无法在函数外访问函数里面定义的变量，但有时候我们又会有这样的需求，这个时候我们就需要使用闭包了。
 
 
2、什么是闭包
 
 
 
在函数A内部再定义一个子函数a，然后子函数a控制父函数中的变量v1，然后在父函数A中把这个子函数a返回给调用方，这个就叫做闭包。
 
 
3、闭包的用途
 
 
 
闭包从编码角度上讲，主要有两种用途
 
 
可以读取整个父级作用域函数内部的变量。
让这些变量的值始终保持在内存中。
 
function fn() {
    var n = 100;

    function getF() {
        return n;
    }

    function setF(newN) {
         return n = newN;
    }
    return {
        getF:getF,
        setF:setF
    }
}
var a = new fn()
a.getF()     //100
a.setF(200)  //200
 
4、注意事项
 
 
 
由于闭包会使得函数中的变量都被保存在内存中，内存消耗很大，所以不能滥用闭包，否则会造成网页的性能问题，在IE中可能导致内存泄露。
解决方法是，在退出函数之前，将不使用的局部变量全部删除。如将当前变量的值设置为“null”，将变量的引用解除，当垃圾回收启动时，会自动对这些值为“null”的变量回收
 
 

回调函数
 
1.什么是回调函数？
 
作为参数的函数就是回调函数！
 
例如：有两个函数A,B如果函数A作为B的一个参数传入B的话，那么我们就称A是回调函数。
 
//声明一个函数
function fn1(a){
    a()
}
//再声明一个函数作为fn1函数的参数传入
function fn2(){
    alert('我是一个回调函数')
}
fn1(fn2)
 
 
例子中的fn2就被称为一个回调函数
 
2.回调函数的用途
 
一般是某个行为或某件事之后的收尾处理，或者说对于不同行为结果，给出不同响应。 
 
闭包【返回一个函数的函数】 
 
1.为什么会产生闭包
 
函数作用域中声明的变量，在全局作用域下是无法进行访问的，但有时候我们又需要在全局中去访问函数内的变量，这个时候我们就需要用到闭包。
 
2.什么是闭包
 
在函数A中，再定义一个函数a，用子函数a去控制父函数A中的变量，调用父函数A时，将子函数a返回给调用者，这就称之为闭包。
 
//定义一个父函数
function A(){
    var i = 1
    //定义一个子函数输出父函数中的变量i
    return  function a(){
        console.log(i)
    }
}
A()() //此处调用一次A函数返回的是一个函数a所以需要在调用一次，所以有两次调用()
 
 
3.闭包的用途 
 
 1）.可以让父级作用域访问到函数中的变量
 
2）.可以让这些变量的值始终保持在内存中
 
//声明一个函数
function boss(){
    var n = 100
    //创建一个子函数，接收一个新的参数
    function child(newV){
    //对传入的参数进行判断，如果没传入新参数返回原来的n值，传入则返回新值
        n = (newV == undefined) ? n : newV
        return n
    }
    return child
}
var myFun = boss()
 
 
 
4.闭包需要注意的事项
 
因为闭包会将这些变量一直存储在内存中，这样对内存消耗极大，影响网页的性能，在IE中可能还会造成内存泄漏。
 
解决这个问题的方法：
 
如将当前变量的值设置为“null”，将变量的引用解除，当垃圾回收启动时，会自动对这些值为“null”的变量回收。

闭包的概念
 
Python 支持函数式编程，所以存在闭包，闭包是由函数及其相关的引⽤环境组合⽽成的实体 ， ⼀句话： 闭包 = 函数+引⽤环境，函数式编程中，当内嵌函数体内引⽤到体外的变量 时， 将会连同这些变量(引⽤环境)和内嵌函数体， ⼀块打包成⼀个整体返回。
 
如果在一个函数的内部定义了另一个函数，外部的我们叫它为外函数，内部的我们叫它内函数，那么闭包就是在一个外函数中定义了一个内函数，内函数里运用了外函数的临时变量，并且外函数的返回值是内函数的引用。
 
一般情况下，在我们认知当中，如果一个函数结束，函数的内部所有东西都会释放掉，还给内存，局部变量都会消失。但是闭包是一种特殊情况，如果外函数在结束的时候发现有自己的临时变量将来会在内部函数中用到，就把这个临时变量绑定给了内部函数，然后自己再结束。
 
简单示例：
 
#闭包函数的实例
# outer是外部函数 a和b都是外函数的临时变量
def outer( a ):
    b = 10
    # inner是内函数
    def inner():
        #在内函数中 用到了外函数的临时变量
        print(a+b)
    # 外函数的返回值是内函数的引用
    return inner

if __name__ == '__main__':
    # 在这里我们调用外函数传入参数5
    #此时外函数两个临时变量 a是5 b是10 ，并创建了内函数，然后把内函数的引用返回存给了demo
    # 外函数结束的时候发现内部函数将会用到自己的临时变量，这两个临时变量就不会释放，会绑定给这个内部函数
    demo = outer(5)
    # 我们调用内部函数，看一看内部函数是不是能使用外部函数的临时变量
    # demo存了外函数的返回值，也就是inner函数的引用，这里相当于执行inner函数
    demo() # 15

    demo2 = outer(7)
    demo2()#17
 
深入理解：
 （1）外函数返回了内函数的引用：
 在python中一切都是对象，包括整型数据1，函数，其实是对象，当我们进行a=1的时候，实际上在内存当中有一个地方存了值1，然后用a这个变量名存了1所在内存位置的引用。引用就好像c语言里的指针，大家可以把引用理解成地址。a只不过是一个变量名字，a里面存的是1这个数值所在的地址，就是a里面存了数值1的引用。
 
相同的道理，当我们在python中定义一个函数def demo(): 的时候，内存当中会开辟一些空间，存下这个函数的代码、内部的局部变量等等。这个demo只不过是一个变量名字，它里面存了这个函数所在位置的引用而已。我们还可以进行x = demo， y = demo， 这样的操作就相当于，把demo里存的东西赋值给x和y，这样x 和y 都指向了demo函数所在的引用，在这之后我们可以用x() 或者 y() 来调用我们自己创建的demo() ，调用的实际上根本就是一个函数，x、y和demo三个变量名存了同一个函数的引用。
 
有了上面的解释，我们可以继续说，返回内函数的引用是怎么回事了。对于闭包，在外函数outer中 最后return inner，我们在调用外函数 demo = outer() 的时候，outer返回了inner，inner是一个函数的引用，这个引用被存入了demo中。所以接下来我们再进行demo() 的时候，相当于运行了inner函数。
 
同时我们发现，一个函数，如果函数名后紧跟一对括号，相当于现在我就要调用这个函数，如果不跟括号，相当于只是一个函数的名字，里面存了函数所在位置的引用。
 
（2）外函数把临时变量绑定给内函数
 按照我们正常的认知，一个函数结束的时候，会把自己的临时变量都释放还给内存，之后变量都不存在了。一般情况下，确实是这样的。但是闭包是一个特别的情况。外部函数发现，自己的临时变量会在将来的内部函数中用到，自己在结束的时候，返回内函数的同时，会把外函数的临时变量送给内函数绑定在一起。所以外函数已经结束了，调用内函数的时候仍然能够使用外函数的临时变量。
 
在我编写的实例中，我两次调用外部函数outer,分别传入的值是5和7。内部函数只定义了一次，我们发现调用的时候，内部函数是能识别外函数的临时变量是不一样的。python中一切都是对象，虽然函数我们只定义了一次，但是外函数在运行的时候，实际上是按照里面代码执行的，外函数里创建了一个函数，我们每次调用外函数，它都创建一个内函数，虽然代码一样，但是却创建了不同的对象，并且把每次传入的临时变量数值绑定给内函数，再把内函数引用返回。虽然内函数代码是一样的，但其实，我们每次调用外函数，都返回不同的实例对象的引用，他们的功能是一样的，但是它们实际上不是同一个函数对象。
 
闭包中内函数修改外函数局部变量
 
在闭包内函数中，我们可以随意使用外函数绑定来的临时变量，但是如果我们想修改外函数临时变量数值的时候发现出问题了
 在基本的python语法当中，一个函数可以随意读取全局数据，但是要修改全局数据的时候有两种方法:1 global 声明全局变量 2 全局变量是可变类型数据的时候可以修改
 
在闭包内函数也是类似的情况。在内函数中想修改闭包变量（外函数绑定给内函数的局部变量）的时候：
 
在python3中，可以用nonlocal 关键字声明 一个变量， 表示这个变量不是局部变量空间的变量，需要向上一层变量空间找这个变量。
 
def rundist(x,y):
    cordx,cordy=x,y

    def move(**kwargs):
        nonlocal cordx
        nonlocal cordy
        if 'x' in kwargs.keys():
            cordx+=kwargs['x']
        if 'y' in kwargs.keys():
            cordy+=kwargs['y']
        print('current position (%d,%d)'%(cordx,cordy))
    return move


if __name__=='__main__':
    mv=rundist(0,0)
    mv(x=5,y=6)
    mv(x=-3)
    mv(y=-7)


'''
current position (5,6)
current position (2,6)
current position (2,-1)
'''
 
若没有使⽤nonlocal关键词显⽰声明cordx，cordy不是局部变量，在执⾏mv(x=5,y=6)时， python 会在move() 中去找在赋值语句右⾯的 cordx 的值， 结果找不到，就会报错UnboundLocalError。
通过使⽤语句 `nonloacal cordx’ 显式的指定 cordx 不是闭包的局部变量， 避免出现 UnboundLocalError。
 
⾯试必考
 
def exfun():
    funli=[]
    for i in range(3):
        def intfun(x):
            print(x*i)
        funli.append(intfun)
    return funli
# 就是⽣成了⼀个list,⾥⾯的3个元素， 元素类型是intfun()函数， 它是⼀个闭包， 引⽤了外部变量i
if __name__=="__main__":
    funli=exfun()
    funli[0](5)
    funli[1](5)
    funli[2](5)

‘’‘
10
10
10
‘’’
 
返回的都是10， 按照我们的期望应该是0,5,10，原因： i 是闭包函数引⽤的外部作⽤域的变量, 只有在内部函数被调⽤的时候， 才会搜索变量i的值。由于循环已结束, i指向最终值2, 所以各函数调⽤都得到了相同的结果。
 
def exfun():
    funli=[]
    for i in range(3):
        def intfun(x):
            print(x*i)
        funli.append(intfun，i=i)
    return funli
# 在⽣成闭包函数的时候， ⽴即绑定变量 i
if __name__=="__main__":
    funli=exfun()
    funli[0](5)
    funli[1](5)
    funli[2](5)

‘’‘
0
5
10
‘’’
 
真正在⾯试中， 这道题会使⽤ lambda 进⼀步隐蔽闭包
 
def exfun():
	return [lambda x: i*x for i in range(3)]

# 期望版本
def exfun():
	return [lambda x,i=i: i*x for i in range(3)]
 
本文章转载自 Python与算法社区 公众号

【Go学习】理解Go语言中的函数闭包
 
闭包是什么？ 
 它是怎么产生的及用来解决什么问题呢。给出字面的定义先：闭包是由函数及其相关的引用环境组合而成的实体(即：闭包=函数+引用环境)。这个从字面上很难理解，至少我在刚接触这个概念的时候是没弄懂的，本文将结合实例代码进行解释。 
 函数是什么？ 
 可能大家都知道：函数只是一段可执行代码，编译后就“固化”了，每个函数在内存中只有一份实例，得到函数的入口点便可以执行函数了。在函数式编程语言中，函数是一等公民（First class value：第一类对象，我们不需要像命令式语言中那样借助函数指针，委托操作函数），函数可以作为另一个函数的参数或返回值，可以赋给一个变量。函数可以嵌套定义，即在一个函数内部可以定义另一个函数，有了嵌套函数这种结构，便会产生闭包问题。如：
 
package main

import "fmt"

func exfunc(base int) func(int) int {
    return func(x int) int {
        return (base + x) 
    }
}


func main() {
    myfunc := exfunc(10)
    fmt.Printf("%10d\n",myfunc(1))

    myanotherfunc := exfunc(20)
    fmt.Printf("%10d\n",myanotherfunc(2))

}
 
运行结果： 
 
 
在这段程序中，我们定义的匿名函数：
 
func(x int) int {
    return (base + x) 
}
 
是函数exfunc的内嵌函数，为方便后面的叙述，我们暂且称这个函数为insfunc，并且是exfunc函数的返回值。我们注意到一个问题：内嵌函数insfunc中引用到外层函数中的局部变量base，Go会这么处理这个问题呢？先让我们来看看这段代码的运行结果。当我们调用分别由不同的参数调用exfunc函数得到的函数时（myfunc(1)，myanotherfunc(2)），得到的结果是隔离的，也就是说每次调用exfunc函数后都将生成并保存一个新的局部变量base。其实这里exfunc函数返回的就是闭包。
 
引用环境： 
 按照命令式语言的规则，exfunc函数只是返回了内嵌函数insfunc的地址，在执行insfunc函数时将会由于在其作用域内找不到base变量而出错。而在函数式语言中，当内嵌函数体内引用到体外的变量时，将会把定义时涉及到的引用环境和函数体打包成一个整体（闭包）返回。现在给出引用环境的定义就容易理解了：引用环境是指在程序执行中的某个点所有处于活跃状态的约束（一个变量的名字和其所代表的对象之间的联系）所组成的集合。闭包的使用和正常的函数调用没有区别。
 
由于闭包把函数和运行时的引用环境打包成为一个新的整体，所以就解决了函数编程中的嵌套所引发的问题。如上述代码段中，当每次调用exfunc函数时都将返回一个新的闭包实例，这些实例之间是隔离的，分别包含调用时不同的引用环境现场。不同于函数，闭包在运行时可以有多个实例，不同的引用环境和相同的函数组合可以产生不同的实例。
 
看到这里，大致应该对闭包有了浅显的认识，我们趁热打铁，再来看一个例子：
 
package main

import "fmt"

func exfunc() func(int) int {
    sum := 0
    return func(x int) int {
        sum += x
        return sum
    }
}


func main() {
    myfunc := exfunc()

    for i := 0;i<10;i++ {
        fmt.Printf("%10d\n",myfunc(i))
    }
}
 
运行结果：
 
         0
         1
         3
         6
        10
        15
        21
        28
        36
        45
 
按照我的理解，结果应该是如下这样：
 
         0
         1
         2
         3
         4
         6
         6
         7
         8 
         9
 
反正我刚开始是没弄懂的，后面我修改了一下代码，加了些打印，让整个过程更加直观：
 
package main

import "fmt"

func exfunc() func(int) int {
    sum := 0
    return func(x int) int {
        fmt.Printf("sum = %10d\n",sum)
        sum += x
        return sum
    }
}


func main() {
    myfunc := exfunc()

    for i := 0;i<10;i++ {
        fmt.Printf("myfunc(%d) = %4d\n",i,myfunc(i))
        fmt.Println("_________________")
    }
}
 
运行结果如下：
 
sum =          0
myfunc(0) =    0
_________________
sum =          0
myfunc(1) =    1
_________________
sum =          1
myfunc(2) =    3
_________________
sum =          3
myfunc(3) =    6
_________________
sum =          6
myfunc(4) =   10
_________________
sum =         10
myfunc(5) =   15
_________________
sum =         15
myfunc(6) =   21
_________________
sum =         21
myfunc(7) =   28
_________________
sum =         28
myfunc(8) =   36
_________________
sum =         36
myfunc(9) =   45
_________________
 
可以看到，sum的生命周期是跟接收exfunc()的变量myfunc的声明周期是一致的，并且sum的值，在每次调用myfunc函数之后，都会改变，并且保存这个改变。这个很像C/C++中局部静态变量的作用，下面我们来一段简单的c代码：
 
#include <stdio.h>

int exfunc(int x)
{
    static int sum = 0;
    sum += x;
    return sum;
}

int main()
{
    int i = 0;
    for(i=0;i<10;i++)
    {
        printf("exfunc(%d) = %4d\n",i,exfunc(i));
    }
    return 0;
}
 
运行结果如下：
 
exfunc(0) =    0
exfunc(1) =    1
exfunc(2) =    3
exfunc(3) =    6
exfunc(4) =   10
exfunc(5) =   15
exfunc(6) =   21
exfunc(7) =   28
exfunc(8) =   36
exfunc(9) =   45
 
可以看到跟我们上面用go闭包的结果一样，但是还是有区别的，我们再来稍微修改一下上面的代码：
 
package main

import "fmt"

func exfunc() func(int) int {
    sum := 0
    return func(x int) int {
        fmt.Printf("sum = %10d\n",sum)
        sum += x
        return sum
    }
}


func main() {
    myfunc := exfunc()

    for i := 0;i<10;i++ {
        fmt.Printf("myfunc(%d) = %4d\n",i,myfunc(i))
        fmt.Println("_________________")
    }


    fmt.Println("*****************")

    anfunc := exfunc()
    fmt.Printf("anfunc(%d) = %4d\n",10,anfunc(10))
}
 
sum =          0
myfunc(0) =    0
_________________
sum =          0
myfunc(1) =    1
_________________
sum =          1
myfunc(2) =    3
_________________
sum =          3
myfunc(3) =    6
_________________
sum =          6
myfunc(4) =   10
_________________
sum =         10
myfunc(5) =   15
_________________
sum =         15
myfunc(6) =   21
_________________
sum =         21
myfunc(7) =   28
_________________
sum =         28
myfunc(8) =   36
_________________
sum =         36
myfunc(9) =   45
_________________
*****************
sum =          0
anfunc(10) =   10
上面的结果可以看出，
 
区别就是C/C++中的静态变量不是独立的，每次调用这个函数，都会使用上次修改的结果，而闭包中的值对于每个闭包是独立存在的。 
 闭包把函数和运行时的引用环境打包成为一个新的整体，如上述代码段中，当每次调用exfunc函数时都将返回一个新的闭包实例，这些实例之间是隔离的，分别包含调用时不同的引用环境现场，比如上面代码中myfunc这个闭包中sum的值经过几次运算后为36，而anfunc这个闭包中sum的值为0。
 
闭包函数出现的条件： 
 1.被嵌套的函数引用到非本函数的外部变量，而且这外部变量不是“全局变量”。 
 2.嵌套的函数被独立了出来(被父函数返回或赋值 变成了独立的个体)， 
 而被引用的变量所在的父函数已结束。
 
看到这么一句话，对闭包的理解，我觉得很透彻，可以作为本文的总结：
 
对象是附有行为的数据，而闭包是附有数据的行为。