匿名函数与闭包
注： 文章仅提供对标题内容的直接讨论，并不提供间接相关知识点的讨论。这些间接涉及的知识点后续可能会更新文章。如果喜欢我的描述方式，欢迎提问并请关注我，留意我的更新。或者也可以直接去找搜索引擎求知。
匿名函数
- 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）是由函数以及创建该函数的上下文中的其他局部变量一起构成的组合。可以实现被捕获参数的状态保持。 - 注意
闭包中使用的变量/参数会一直保存在内存中，所以会一直使用（可以连续操作）。所以！闭包不可滥用！
go
代码解读
复制代码
//函数功能求和；函数名：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）的场景。
- 代码清晰：使用闭包可以减少外部的依赖和全局变量的使用，从而使代码更加清晰和可维护。（尽管确实代码数少了些，但我个人认为逻辑性变差了，我更重视逻辑）
如果不使用闭包累加实现方法：
（使用了全局结构体字段的保存方法）
go
代码解读
复制代码
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))
}
如果直接定义一个累加函数，它的返回值并不会被保存，只有闭包中的值会被全局保存，可以完成全局的任意调用。
go
代码解读
复制代码
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
}
闭包保持状态的原理
因为闭包中引用的是地址（也可以理解为闭包内捕获的外界变量其实都是它们的指针），因此输出结果取决于这个地址上，输出时存储的是什么值。而不是和普通变量一样是固定的。
css
代码解读
复制代码
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。
go
代码解读
复制代码
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 支持轻量、便捷的协程功能，它可以实现多进程的异步执行。不同协程间对共享数据的异步访问，使用闭包就可以更加的简单高效。如下：
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)
}
- 初始化同步机制：
- var wg sync.WaitGroup：声明一个 WaitGroup，用于等待所有协程完成。
- var mu sync.Mutex：声明一个互斥锁，用于保护共享数据的访问。
- 创建闭包函数：
- increment 是一个闭包函数，它捕获了外部的 mu 和 counter 变量。
- 在闭包内部，使用 mu.Lock() 和 mu.Unlock() 来确保对 counter 的访问是安全的。
- defer 关键字用于确保在函数返回时解锁，即使发生了 panic。
- 启动协程：
- 使用 for 循环启动多个协程，每个协程都会执行 increment 闭包。
- 每个协程启动时，wg.Add(1) 增加 WaitGroup 计数器。
- 在协程内，使用 defer wg.Done() 确保协程完成时通知 WaitGroup。
协程的数据访问还会有同步、安全等问题，这些问题的解决需要结合读写锁等其他方法来讲。因此这里不做详细解释，后续我会在写完前置技能点后，进行一次整体的分析、解释。欢迎关注我的账号等待更新。
