Go 匿名函数和闭包

匿名函数和闭包是 Go 语言中极其强大且富有表现力的特性。它们允许你在没有名字的情况下定义函数，并能够“捕获”周围环境中的变量。

这为编写动态的、可复用的代码块以及实现函数式编程范式打开了大门。

本章我们将抽丝剥茧，彻底搞懂匿名函数怎么写，以及闭包底层的“记忆”机制到底是怎么回事。

1. 匿名函数 (Anonymous Functions)

顾名思义，匿名函数（在很多其他语言中被称为 Lambda 表达式）就是没有名字的函数。当我们只需要在某个局部地方执行一段简短、一次性的逻辑，专门为它起个名字并在包级别声明它显得过于繁琐时，匿名函数就派上用场了。

1.1 定义与调用匿名函数

在 Go 中，你只需要保留 func 关键字、参数列表和返回值，直接省略函数名即可定义它。你可以把它赋值给一个变量，或者在定义完后立刻执行它（这叫立即执行函数 IIFE）。

package main

import "fmt"

func main() {
	// 方式 1：将匿名函数赋值给一个变量
	add := func(x, y int) int {
		return x + y
	}
	
	// 通过变量名来调用这个匿名函数
	result := add(5, 3)
	fmt.Println("赋值调用结果:", result) // 输出: 8

	// 方式 2：定义后立刻调用 (注意大括号末尾的括号和小括号里的参数)
	result2 := func(x, y int) int {
		return x * y
	}(5, 3) // 这里的 (5, 3) 就是立即传入的参数
	
	fmt.Println("立即执行结果:", result2) // 输出: 15
}

1.2 将匿名函数作为参数传递 (回调函数)

在 Go 中，函数是“一等公民 (First-class citizens)”，这意味着函数可以像普通的 int 或 string 变量一样被到处传递。接收其他函数作为参数的函数，被称为高阶函数 (Higher-order functions)。

package main

import "fmt"

// operate 接收两个数字，以及一个“定义了具体运算规则”的函数作为参数
func operate(x, y int, operation func(int, int) int) int {
	return operation(x, y) // 执行传入的函数
}

func main() {
	// 传入一个执行减法的匿名函数
	result1 := operate(10, 5, func(a, b int) int {
		return a - b
	})
	fmt.Println("减法结果:", result1) // 输出: 5

	// 传入一个执行加法的匿名函数
	result2 := operate(10, 5, func(a, b int) int {
		return a + b
	})
	fmt.Println("加法结果:", result2) // 输出: 15
}

这种模式极其强大，它将具体的“操作行为”作为参数动态注入，极大地提升了代码的灵活性。

1.3 让函数返回另一个函数

同理，一个函数也可以把另一个匿名函数当作结果返回。这被称为“工厂模式”，用于生成具有特定行为的定制化函数。

package main

import "fmt"

// multiplier 是一个工厂函数，它接收一个倍数 factor，
// 并返回一个定制好的匿名函数。
func multiplier(factor int) func(int) int {
	return func(x int) int {
		return x * factor
	}
}

func main() {
	// 制造一个专门“乘以 5”的函数
	multiplyByFive := multiplier(5)
	// 制造一个专门“乘以 10”的函数
	multiplyByTen := multiplier(10)

	fmt.Println(multiplyByFive(3))  // 输出: 15
	fmt.Println(multiplyByTen(3))   // 输出: 30
}

仔细思考一下上面的代码：当 multiplier(5) 执行完毕后，它本该销毁局部的 factor 变量。但为什么返回的 multiplyByFive 函数在后续调用时，依然能“记住” factor 是 5 呢？这就引出了下面极其关键的概念：闭包。

2. 闭包 (Closures)

闭包就是一个匿名函数，外加它被创建时所能访问的外部变量的引用。 简单来说，闭包不仅包含代码逻辑，还把周围环境的变量给“打包”带走了，所以它拥有记忆能力。

2.1 捕获变量引用的底层原理

当闭包捕获外部变量时，它捕获的不是那个变量当时的值的拷贝，而是那个变量的内存地址（引用）。这意味着，如果外部变量的值后来发生了改变，闭包内部也能感知到最新的值；反之，闭包在内部修改了这个变量，外部也能看到。

来看一个经典的“计数器”例子：

package main

import "fmt"

// counter 返回一个闭包函数，该闭包不仅包含递增逻辑，
// 还悄悄“绑定”了外层的局部变量 count。
func counter() func() int {
	count := 0 // 这个局部变量被闭包捕获了
	return func() int {
		count++    // 每次调用闭包，都在修改外层的 count
		return count
	}
}

func main() {
	// 创建两个完全独立的计数器工厂实例
	increment1 := counter()
	increment2 := counter()

	fmt.Println(increment1()) // 输出: 1 (count 变成 1)
	fmt.Println(increment1()) // 输出: 2 (count 变成 2)
	
	// increment2 拥有自己独立的闭包环境和 count 变量
	fmt.Println(increment2()) // 输出: 1 
	
	fmt.Println(increment1()) // 输出: 3
	fmt.Println(increment2()) // 输出: 2
}

在这里，即使 counter 函数早就执行完毕退出了，但因为内部返回的匿名函数仍然在引用 count，所以 count 的生命周期被延长了，它的值被安全地“封装”在了闭包的记忆里。这就是状态管理 (State Management) 的一种高级形态。

2.2 经典陷阱：闭包与 for 循环

这是 Go 语言初学者（甚至老手）最容易踩的坑。因为闭包捕获的是引用，当我们在 for 循环中创建多个闭包，并且这些闭包都引用了同一个循环计数器变量时，灾难就发生了。

package main

import "fmt"

func main() {
	var functions []func() // 存放一堆函数的切片

	for i := 0; i < 5; i++ {
		// 错误做法：直接在闭包里捕获了循环变量 i
		functions = append(functions, func() {
			fmt.Println("错误的 i:", i) 
		})
	}

	// 循环结束时，i 的值已经是 5 了。
	// 此时依次执行切片里保存的函数：
	for _, f := range functions {
		f() // 糟糕！它们全都会打印 5
	}

	fmt.Println("--- 正确的分割线 ---")

	var functions2 []func()
	for i := 0; i < 5; i++ {
		// 正确做法：每次循环时，创建一个局部副本 i
		// 把外面的 i 拷贝给里面这个属于当前代码块的 i
		i := i 
		functions2 = append(functions2, func() {
			fmt.Println("正确的 i:", i) // 这里捕获的是那个局部副本
		})
	}

	for _, f := range functions2 {
		f() // 正确输出 0, 1, 2, 3, 4
	}
}

原理解析： 在第一段错误代码中，所有的匿名函数都指向了同一块名叫 i 的内存地址。当它们最后真正被执行时，去那个地址一看，里面装的早就是循环结束后的最终值 5 了。

而在正确的代码中，每次循环都会声明一个全新的、只属于本次循环的变量 i := i（发生了变量遮蔽）。此时每个闭包捕获的都是各自私有的那个副本，因此不会互相干扰。(注：在最新的 Go 1.22+ 版本中，官方已经修改了 for 循环的底层语义，这个问题默认已被修复，但理解这个原理对于阅读老代码依然极其重要！)