Go——闭包

客官°小女子只卖身不卖艺 2023-10-09 20:53 8阅读 0赞

### 概念 ###

闭包是由函数及其相关引用环境组合而成的实体，一般通过在匿名函数中引用外部函数的局部变量或包全局变量构成。

闭包=函数+引用环境

闭包对闭包外的环境引入是直接引用，编译器检测到闭包，会将闭包引用的外部变量分配到堆上。

如果函数返回的闭包引用了该函数的局部变量（参数或函数内部变量）：

1.  多次调用该函数，返回的多个闭包所引用的外部变量是多个副本，原因是每次调用函数都会为局部变量分配内存。
2.  用一个闭包函数多次，如果该闭包修改了其引用的外部变量，则每一次调用该闭包对该外部变量都有影响，因为闭包函数共享外部引用。

示例如下：

package main
    
    func main() {
        
    	f := fa(1) //f引用的外部的闭包环境包括本次函数调用的形参a的值1
    	g := fa(1) //g引用的外部的闭包环境包括本次函数调用的形参a的值1
    
    	//此时f、g引用的闭包环境中的a并不是同一个，而是两次函数调用产生的副本
    
    	println(f(1))
    	//多次调用f引用的是同一个副本
    	println(f(1))
    
    	//g中a的值仍然是1
    	println(g(1))
    	println(g(1))
    }
    
    func fa(a int) func(i int) int {
        
    	return func(i int) int {
        
    		println(&a, a)
    		a = a + i
    		return a
    	}
    }
    
    
    //运行结果
    0xc42001c058 1
    2
    0xc42001c058 2
    3
    0xc42001c070 1
    2
    0xc42001c070 2
    3

f和g引用的是不同的a。

如果一个函数调用返回的闭包引用修改了全局变量，则每次调用都会影响全局变量。

如果函数返回的闭包引用的是全局变量，则多次调用该函数返回的多个闭包引用的都是同一个a。同理，调用一个闭包多次引用的也是同一个a。此时如果闭包中修改了a值的逻辑，则每次闭包调用都会影响全局变量的值。使用闭包是为了减少全局变量，所以闭包引用全局变量不是好的编程方式。

示例如下：

package main
    
    var (
    	a = 0
    )
    
    func main() {
        
    	f := fa() //f应用的外部的闭包环境包括全局变量a
    	g := fa() //g引用的外部的闭包环境包括全局变量a
    
    	//此时f、g引用的闭包环境中a的值是同一个
    
    	println(f(1))
    	println(f(1))
    	println(g(1))
    	println(g(1))
    }
    
    func fa() func(i int) int {
        
    	return func(i int) int {
        
    		println(&a, a)
    		a = a + i
    		return a
    	}
    }
    
    //程序运行结果
    0x10c6468 0
    1
    0x10c6468 1
    2
    0x10c6468 2
    3
    0x10c6468 3
    4

同一个函数返回的多个闭包共享该函数的局部变量。例如：

package main
    
    func main() {
        
    	//f、g闭包引用的base是同一个，是fa函数调用传递过来的实参值
    	f, g := fa(0)
    
    	//s、k闭包引用的base是同一个，是fa函数调用传递过来的实参值
    	s, k := fa(0)
    
    	//f、g和s、k引用不同的闭包变量，这是由于fa每次调用都要重新分配形参
    	println(f(1), g(2))
    	println(s(1), k(2))
    }
    
    func fa(base int) (func(int) int, func(int) int) {
        
    	println(&base, base)
    
    	add := func(i int) int {
        
    		base += i
    		println(&base, base)
    		return base
    	}
    
    	sub := func(i int) int {
        
    		base -= i
    		println(&base, base)
    		return base
    	}
    
    	return add, sub
    }
    
    
    //程序运行结果
    0xc42001c058 0
    0xc42001c070 0
    0xc42001c058 1
    0xc42001c058 -1
    1 -1
    0xc42001c070 1
    0xc42001c070 -1
    1 -1

### 闭包的价值 ###

闭包最初的目的是减少全局变量，在函数调用的过程中隐式地传递共享变量，有其有用的一面；但是这种隐秘的共享变量的方式带来的坏处是不够直接，不够清晰，除非是非常有价值的地方，一般不建议使用闭包。

对象是附有行为的数据，而闭包是附有数据的行为，类在定义时已经显式地集中定义了行为，但是闭包中的数据没有显式地集中声明的地方，这种数据和行为耦合的模型不是一种推荐的编程模型，闭包仅仅是锦上添花的东西，不是不可缺少的。