Go的闭包、匿名函数和defer的一些问题

Love The Way You Lie 2021-10-06 12:50 393阅读 0赞

所谓闭包是指内层函数引用了外层函数中的变量或称为引用了自由变量的函数，其返回值也是一个函数，了解过的语言中有闭包概念的像 js，python，golang 都类似这样。

python 中的闭包可以嵌套函数，像下面这样：

def make_adder(addend):
        def adder(augend):
            return augend + addend
        return adder

*转化成 golang 代码则像下面这样：*

func outer(x int) func(int) int{
        func inner(y int) int{
            return x + y
        }
        return inner
    }

**当然这是错误的，golang 中是不能嵌套函数的**，但是可以在一个函数中包含匿名函数，完整示例像下面这样：

package main
    
    import (
        "fmt"
    )
    
    func outer(x int) func(int) int {
        return func(y int) int {
            return x + y 
        }   
    }
    
    func main() {
        f := outer(10)
        fmt.Println(f(100))
    }

看了一段时间 golang 后，对于 golang 中的闭包可能出现的坑大致有下面几个。

--------------------

**1，for range 中使用闭包**

一个示例：

func main() {                
        s := []string{
       "a", "b", "c"}                             
        for _, v := range s { 
            go func() {
                fmt.Println(v)
            }()                 
        }                        
        select {}    // 阻塞模式 
    }                          
    
    // 嗯，结果应该是 a,b,c 吧

来看看结果：  
![这里写图片描述][70]  
运行结果  
输出的结果不期而然，大家的结果也不一定和我相同。

对比下面的改进：

func main() {                
        s := []string{
       "a", "b", "c"}                             
        for _, v := range s { 
            go func(v string) {
                fmt.Println(v)
            }(v)   //每次将变量 v 的拷贝传进函数 
        }                        
        select {}                                                      
    }

所以结果当然是:

"a"
    "b"
    "c"

由于使用了 go 协程，并非顺序输出。

**在没有将变量 v 的拷贝值传进匿名函数之前，只能获取最后一次循环的值,这是新手最容易遇到的坑。**

--------------------

**2，函数列表使用不当**

package main
    
    import (
        "fmt"
    )
    
    func test() []func() {
        var s []func()
    
        for i := 0; i < 3; i++ {
            s = append(s, func() {  //将多个匿名函数添加到列表
                fmt.Println(&i, i)
            })
        }
    
        return s    //返回匿名函数列表
    }
    func main() {
        for _, f := range test() {  //执行所有匿名函数
            f()   
        }
    }

运行结果：  
![这里写图片描述][70 1]

解决方法：

package main
    
    import (
        "fmt"
    )
    
    func test() []func() {
        var s []func()
    
        for i := 0; i < 3; i++ {
            x := i                  //复制变量
            s = append(s, func() {
                fmt.Println(&x, x)
            })
        }
    
        return s
    }
    func main() {
        for _, f := range test() {
            f()
        }
    }

**每次 append 操作仅将匿名函数放入到列表中，但并未执行，并且引用的变量都是 i，随着 i 的改变匿名函数中的 i 也在改变，所以当执行这些函数时，他们读取的都是环境变量 i 最后一次的值。解决的方法就是每次复制变量 i 然后传到匿名函数中，让闭包的环境变量不相同。**

若是你对闭包理解了，也可以利用闭包来修改全局变量：

package main                   
    
    import (                       
        "fmt"                      
    )                              
    
    var x int = 1                  
    
    func main() {                  
        y := func() int {          
            x += 1                 
            return x               
        }()                        
        fmt.Println("main:", x, y)                                                            
    } 
    
    // 结果： main: 2 2

--------------------

**3，延迟调用**

defer 调用会在当前函数执行结束前才被执行，这些调用被称为延迟调用，  
defer 中使用匿名函数依然是一个闭包。

package main
    
    import "fmt"
    
    func main() {
        x, y := 1, 2
    
        defer func(a int) { 
            fmt.Printf("x:%d,y:%d\n", a, y)  // y 为闭包引用
        }(x)      // 复制 x 的值
    
        x += 100
        y += 100
        fmt.Println(x, y)
    }

输出结果：

101 102
    x:1,y:102

--------------------

**再看一个例子：**

package main  
    
    import (  
        "fmt"  
    )  
    
    func main() {  
        var fs = [4]func(){} //声明一个function类型的slice，长度为4 
    
        for i := 0; i < 4; i++ {  
            defer fmt.Println("defer i= ", i)                       //这是一个i作为参数传进去的输出，因为i是int型，所以遵循一个规则值拷贝的传递，还有defer是倒序执行的，所以先后输出3,2,1,0，跟下面的defer交替执行4次 
            defer func() { fmt.Println("defer_closure i = ", i) }() //执行完下面的代码后，到了该defer了，这也是一个匿名函数，同样的也没有参数，也没有定义i，所以这也是个闭包，用的也是外面的i，所以先输出4，接着执行上面的defer，这样反复执行4次 
            fs[i] = func() { fmt.Println("closure i = ", i) }       //把相应的4个匿名函数存到function类型的slice里，因为这是个匿名函数，又没有参数，且也没有定义i，所以i就是外层函数的地址引用，就是for循环的i的地址，执行完for后i的值为4，所以输出4个4 
        }  
    
        for _, f := range fs { //用for循环对slice的调用，f为slice的值，即匿名函数，而f()则是对匿名函数的调用 
            f()  
        }  
    }

结果：

![70 2][]

--------------------

**总结：从形式上看，匿名函数都是闭包。闭包的使用非常灵活，上面仅是几个比较简单的示例，不当的使用容易产生难以发现的 bug，当出现意外情况时，首先检查函数的参数，声明可以接收参数的匿名函数，这些类型的闭包问题也就引刃而解了。**

转载自：  
[https://www.jianshu.com/p/fa21e6fada70][https_www.jianshu.com_p_fa21e6fada70]

[70]: /images/20211006/1007151fa83049c099f681e09d755b5f.png
[70 1]: /images/20211006/85594181da784a84b12ca2a6b079aff1.png
[70 2]: /images/20211006/a521e678d6974ec4a69c9a5a5eece3eb.png
[https_www.jianshu.com_p_fa21e6fada70]: https://www.jianshu.com/p/fa21e6fada70