在 Go 语言中，匿名函数（Anonymous Function）是一种没有明确名称的函数，可以直接定义并使用，无需提前声明。它是 Go 中灵活且常用的特性，尤其适合实现简单逻辑、回调函数或封装临时逻辑。
一、匿名函数的基本语法
匿名函数的定义格式与普通函数类似，但省略了函数名，语法如下：
func(参数列表) (返回值列表) {
// 函数体
}
匿名函数可以直接调用，也可以赋值给变量，或作为参数 / 返回值传递。
二、匿名函数的使用场景
1. 直接调用（立即执行）
匿名函数定义后可以直接调用，适用于一次性的简单逻辑：
package main
import "fmt"
func main() {
// 定义匿名函数并立即调用
func() {
fmt.Println("匿名函数被调用了")
}() // 注意末尾的 () 表示调用
// 带参数的匿名函数
func(name string) {
fmt.Printf("Hello, %s\n", name)
}("Go") // 传递参数 "Go"
}
输出：
匿名函数被调用了 Hello, Go
2. 赋值给变量
匿名函数可以赋值给函数类型的变量，后续通过变量调用：
package main
import "fmt"
func main() {
// 匿名函数赋值给变量
add := func(a, b int) int {
return a + b
}
// 通过变量调用
result := add(3, 5)
fmt.Println(result) // 输出：8
}
这里的 add 本质是一个函数类型变量，类型为 func(int, int) int。
3. 作为函数参数（回调函数）
匿名函数常作为参数传递给其他函数，实现回调逻辑：
package main
import "fmt"
// 接收一个函数作为参数（回调函数）
func process(nums []int, callback func(int) int) []int {
result := []int{}
for _, n := range nums {
result = append(result, callback(n))
}
return result
}
func main() {
numbers := []int{1, 2, 3, 4}
// 传递匿名函数作为回调（实现翻倍逻辑）
doubled := process(numbers, func(n int) int {
return n * 2
})
fmt.Println(doubled) // 输出：[2 4 6 8]
// 传递另一个匿名函数（实现平方逻辑）
squared := process(numbers, func(n int) int {
return n * n
})
fmt.Println(squared) // 输出：[1 4 9 16]
}
4. 作为函数返回值
匿名函数可以作为其他函数的返回值，实现 “函数工厂” 模式（根据输入生成不同逻辑的函数）：
package main
import "fmt"
// 返回一个函数（根据前缀生成打招呼的函数）
func greeter(prefix string) func(string) string {
return func(name string) string {
return fmt.Sprintf("%s, %s", prefix, name)
}
}
func main() {
// 生成 "Hello" 前缀的函数
hello := greeter("Hello")
fmt.Println(hello("Go")) // 输出：Hello, Go
// 生成 "Hi" 前缀的函数
hi := greeter("Hi")
fmt.Println(hi("World")) // 输出：Hi, World
}
三、匿名函数与闭包（Closure）
匿名函数通常与闭包结合使用。闭包是指函数可以捕获并访问其外部作用域中的变量，即使外部函数已经返回。
闭包示例：
package main
import "fmt"
func counter() func() int {
count := 0 // 外部变量，被匿名函数捕获
return func() int {
count++ // 访问并修改外部变量
return count
}
}
func main() {
c1 := counter()
fmt.Println(c1()) // 1
fmt.Println(c1()) // 2（count 被持续修改）
c2 := counter()
fmt.Println(c2()) // 1（c2 拥有独立的 count）
}
- 匿名函数捕获了外部函数
counter中的count变量。 - 每个通过
counter()创建的函数（如c1、c2）都拥有独立的count副本，彼此不受影响。
四、匿名函数的注意事项
1. 变量捕获的 “延迟绑定”
匿名函数捕获外部变量时，是引用捕获而非值拷贝，且绑定是 “延迟的”（直到函数执行时才获取变量当前值）：
package main
import "fmt"
func main() {
for i := 0; i < 3; i++ {
// 错误示例：匿名函数捕获的是 i 的引用，循环结束后 i=3
defer func() {
fmt.Println(i) // 输出：3 3 3（而非 0 1 2）
}()
}
}
解决方法：通过参数传递当前值，避免引用捕获：
for i := 0; i < 3; i++ {
// 正确：将 i 的当前值作为参数传入
defer func(n int) {
fmt.Println(n) // 输出：2 1 0（defer 逆序执行）
}(i)
}
2. 避免在循环中创建闭包并异步执行
如果在循环中创建闭包并用于 goroutine（异步执行），可能因变量延迟绑定导致结果不符合预期：
package main
import (
"fmt"
"time"
)
func main() {
for i := 0; i < 3; i++ {
// 错误：goroutine 执行时 i 可能已变为 3
go func() {
fmt.Println(i) // 可能输出：3 3 3（非预期）
}()
}
time.Sleep(time.Second) // 等待 goroutine 执行
}
解决方法：通过参数传递当前值：
五、匿名函数的优势
- 简化代码：对于简单逻辑，无需单独定义函数，减少代码量。
- 灵活传递：作为参数或返回值，轻松实现回调、策略模式等。
- 封装状态：结合闭包可以封装私有变量，实现类似 “对象” 的状态保持（如计数器、缓存等）。
六、总结
匿名函数是 Go 中一种轻量、灵活的函数形式，主要用于：
- 一次性简单逻辑的立即执行；
- 作为回调函数、参数或返回值传递；
- 结合闭包捕获外部变量，实现状态封装。
使用时需注意变量捕获的 “延迟绑定” 问题，尤其是在循环或异步场景中，避免因引用捕获导致逻辑错误。合理使用匿名函数可以让代码更简洁、更具表达力。