go语言中闭包与匿名函数是什么？

转载

科技最前线 2024-08-07 13:42:16

文章标签 匿名函数 Group 全局变量 文章分类 Go语言后端开发

匿名函数与闭包

注：文章仅提供对标题内容的直接讨论，并不提供间接相关知识点的讨论。这些间接涉及的知识点后续可能会更新文章。如果喜欢我的描述方式，欢迎提问并请关注我，留意我的更新。或者也可以直接去找搜索引擎求知。

匿名函数

Go支持匿名函数，如果我们某个函数只是希望使用一次，可以使用匿名函数，书写简单更加高效
匿名函数使用方式：

定义匿名函数时直接调用，这种方式只能调用一次
将匿名函数赋给一个变量（该变量就是函数变量了），再通过该变量来调用匿名函数

将匿名函数给一个全局变量，就可以让匿名函数在整个程序中有效。

func mian(){
	//定义匿名函数：定义的同时调用，匿名函数不需要函数名
	result := func (num1 int,num2 int) int{
		return num1 + num2
	}(10,20)

	fmt.Println(result)

	sub := func (num1 int,num2 int) int{
		return num1 - num2
	}
	result01 := sub(30,70)
	fmt.Println(result01)
}
//同样可以在外部定义，也可以给全局变量

闭包

（非函数式编程不推荐使用，内存管理复杂且难以运维！个人更推荐采用全局变量、全局结构体的字段等方法进行状态保持）

什么是闭包
闭包就是一个匿名函数和被捕获的参数
闭包的本质
闭包（Closure）是由函数以及创建该函数的上下文中的其他局部变量一起构成的组合。可以实现被捕获参数的状态保持。
注意

闭包中使用的变量/参数会一直保存在内存中，所以会一直使用（可以连续操作）。所以！闭包不可滥用！

//函数功能求和；函数名：getSum 参数为空；返回值为func (int)
//这个返回值函数中的参数是int参数，返回值也是int
func getSum() func (int) int {
	var sum int = 0
	return func (num int) int {
		sum = sum + num
		return sum
	}
}

func main(){
	f := getSum()
	fmt.Println(f(1))
	fmt.Println(f(2))
}

以上代码中使用闭包的好处：

状态保持：通过闭包，我们可以将状态（在这里是sum）与操作该状态的函数绑定在一起。这意味着我们可以在不同的调用之间保持和更新状态，而无需使用全局变量。
简洁性：闭包提供了一种简洁的方式来封装和操作状态，而无需使用传统的类和对象。
可重用性：由于闭包可以访问其外部函数的变量，所以它可以用于不同的情境。在这个例子中，返回的匿名函数可以用于任何需要累加器（accumulator）的场景。
代码清晰：使用闭包可以减少外部的依赖和全局变量的使用，从而使代码更加清晰和可维护。（尽管确实代码数少了些，但我个人认为逻辑性变差了，我更重视逻辑）

如果不使用闭包累加实现方法：

（使用了全局结构体字段的保存方法）

type Accumulator struct {  
	sum int  
}  
  
func (a *Accumulator) Add(num int) int {  
	a.sum += num  
	return a.sum  
}  
  
func main() {  
	acc := &Accumulator{}  
	fmt.Println(acc.Add(1))  
	fmt.Println(acc.Add(2))  
}

如果直接定义一个累加函数，它的返回值并不会被保存，只有闭包中的值会被全局保存，可以完成全局的任意调用。

func getSum() func (int) int {
	var sum int = 0
	return func (num int) int {
		sum = sum + num
		return sum
	}
}
//闭包：返回的匿名函数+匿名函数以外的变量num

func main(){
	f := getSum()
	fmt.Println(f(1))
	fmt.Println(f(2))

	fmt.Println("----------")

	fmt.Println(getSum01(1))
	fmt.Println(getSum01(2))
	
	fmt.Println("----------")

	fmt.Println(getSum02(0,1))//这里其实可以用函数内变量来做值继承
	fmt.Println(getSum02(1,2))
}

func getSum01(num int) int{
	var sum int = 0
	sum = sum + num
	return sum
}

func getSum02(sum int,num int) int{
	sum = sum + num
	return sum
}

闭包保持状态的原理

因为闭包中引用的是地址（也可以理解为闭包内捕获的外界变量其实都是它们的指针），因此输出结果取决于这个地址上，输出时存储的是什么值。而不是和普通变量一样是固定的。

func main(){
	var funcSlice []func()
	for i := 0; i < 3; i++ {
		fmt.Println(i) // 输出的本质：0xc0000ac1d0 0xc0000ac1d0 0xc0000ac1d0
		funcSlice = append(funcSlice, func() {
			fmt.Println(i)
		})
	}

	for j := 0; j < 3; j++ {
		funcSlice[j]() // 此时的i所在的地址：0xc0000ac1d0所存储的是最后一次循环后i的值
	}
}

加中介以开辟新地址

中间增加了一个新的入参作为中介，每次循环到func(i int)，都会有一个新的参数创建，每次创建的新参数，地址都不相同，funcSlice中引用的都是一个新的i。

func main(){
	var funcSlice []func()
	for i := 0; i < 3; i++ {
		fmt.Println(i) // 0xc0000ac1d0 0xc0000ac1d0 0xc0000ac1d0
		func(i int){
			funcSlice = append(funcSlice, func() {
				fmt.Println(i)
			})
		}(i)
		
	}

	for j := 0; j < 3; j++ {
		funcSlice[j]() // 0xc0000ac1d0 0xc0000ac1d0 0xc0000ac1d0
	}
}

Go 中闭包的独特使用场景

众所周知，Go 支持轻量、便捷的协程功能，它可以实现多进程的异步执行。不同协程间对共享数据的异步访问，使用闭包就可以更加的简单高效。如下：

func main() {
	var wg sync.WaitGroup
	var mu sync.Mutex
	counter := 0

	// 创建一个闭包函数，用于安全地递增计数器
	increment := func() {
		mu.Lock()         // 加锁
		defer mu.Unlock() // 确保在函数结束时解锁
		counter++
		fmt.Println("Counter:", counter)
	}

	// 启动多个协程，执行闭包函数
	for i := 0; i < 5; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done() // 确保在协程结束时通知WaitGroup
			increment()
		}()
	}

	// 等待所有协程完成
	wg.Wait()
	fmt.Println("Final Counter:", counter)
}