Go-05-函数、闭包与一等公民

2026-08-28

字数统计: 1.6k字 | 阅读时长≈ 8分

Go-05-函数、闭包与一等公民

本节目标：掌握 Go 函数的多返回值、可变参数、闭包、defer，理解”函数是一等公民”。

1. 函数基础

// 普通函数
func add(a, b int) int {
    return a + b
}

// 多返回值
func divmod(a, b int) (int, int) {
    return a / b, a % b
}

// 命名返回值
func rect(width, height int) (area, perimeter int) {
    area = width * height
    perimeter = 2 * (width + height)
    return  // 裸 return，返回命名变量
}

// 错误返回约定：最后一个返回值是 error
func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, fmt.Errorf("division by zero")
    }
    return a / b, nil
}

2. 函数是一等公民

函数可以赋值给变量、传参、作为返回值、放进 map/struct：

// 函数类型
type BinaryOp func(int, int) int

func add(a, b int) int { return a + b }
func mul(a, b int) int { return a * b }

func main() {
    // 赋值给变量
    var op BinaryOp = add
    fmt.Println(op(3, 4))  // 7

    op = mul
    fmt.Println(op(3, 4))  // 12

    // 直接传函数字面量
    result := apply(3, 4, func(a, b int) int { return a - b })
    fmt.Println(result)  // -1
}

func apply(a, b int, op BinaryOp) int {
    return op(a, b)
}

3. 闭包（Closure）

闭包 = 函数 + 其引用的外部变量：

func counter() func() int {
    n := 0
    return func() int {
        n++
        return n
    }
}

func main() {
    c1 := counter()
    fmt.Println(c1())  // 1
    fmt.Println(c1())  // 2
    fmt.Println(c1())  // 3 ← n 在 c1 的闭包里累加

    c2 := counter()
    fmt.Println(c2())  // 1 ← c2 有自己的 n
}

经典例子：斐波那契生成器：

func fibGen() func() int {
    a, b := 0, 1
    return func() int {
        a, b = b, a+b
        return a
    }
}

func main() {
    f := fibGen()
    for i := 0; i < 10; i++ {
        fmt.Println(f())  // 1 1 2 3 5 8 13 21 34 55
    }
}

闭包陷阱：循环变量共享（Go 1.22 之前）：

funcs := []func(){}
for i := 0; i < 3; i++ {
    funcs = append(funcs, func() {
        fmt.Println(i)
    })
}
for _, f := range funcs {
    f()  // 全部输出 3 3 3 ← i 共享同一个变量
}

// 修复 1：每次循环新建变量
for i := 0; i < 3; i++ {
    i := i  // 显式 shadow
    funcs = append(funcs, func() {
        fmt.Println(i)
    })
}

// 修复 2：传参
for i := 0; i < 3; i++ {
    funcs = append(funcs, func(i int) func() {
        return func() { fmt.Println(i) }
    }(i))
}

// Go 1.22+：循环变量每轮独立（已修复）

4. 可变参数

func sum(nums ...int) int {
    total := 0
    for _, n := range nums {
        total += n
    }
    return total
}

sum(1, 2, 3)        // 6
sum()               // 0
nums := []int{4, 5, 6}
sum(nums...)        // 15，展开切片

混合参数（固定参数在前，可变参数在后）：

1
2
3

func printf(format string, args ...interface{}) {
    // fmt.Printf 本身就是这个签名
}

5. defer：延迟执行

defer 把函数调用推迟到当前函数返回前执行：

func readFile(path string) error {
    f, err := os.Open(path)
    if err != nil {
        return err
    }
    defer f.Close()  // 函数返回前自动关文件

    // 读文件...
    return nil
}

多个 defer：后进先出（LIFO）

func main() {
    defer fmt.Println("1")
    defer fmt.Println("2")
    defer fmt.Println("3")
}
// 输出：3 2 1

defer 经典用法：资源清理

func process() (err error) {
    conn, err := net.Dial("tcp", "example.com:80")
    if err != nil {
        return
    }
    defer conn.Close()

    // 即使中间 panic，conn 也会被关闭
    // ...
    return
}

defer 闭包陷阱：

func main() {
    for i := 0; i < 3; i++ {
        defer func() {
            fmt.Println(i)  // 输出 3 3 3（defer 在 return 后才执行，此时 i=3）
        }()
    }
}

// 修复：传参
for i := 0; i < 3; i++ {
    defer func(v int) {
        fmt.Println(v)
    }(i)
}
// 输出 2 1 0

6. 匿名函数与高阶函数

// 立即执行
func main() {
    func() {
        fmt.Println("立即执行")
    }()

    // 带参数
    func(name string) {
        fmt.Println("Hello,", name)
    }("Go")
}

Map 里的函数（命令模式）：

commands := map[string]func(){
    "start": func() { fmt.Println("starting...") },
    "stop":  func() { fmt.Println("stopping...") },
    "pause": func() { fmt.Println("paused") },
}
commands["start"]()

7. 函数式风格：filter / map / reduce

Go 不像 Python 那样有内建，但用泛型可以自己写：

func Filter[T any](s []T, pred func(T) bool) []T {
    result := []T{}
    for _, v := range s {
        if pred(v) {
            result = append(result, v)
        }
    }
    return result
}

func Map[T, U any](s []T, f func(T) U) []U {
    result := make([]U, len(s))
    for i, v := range s {
        result[i] = f(v)
    }
    return result
}

func Reduce[T any](s []T, init T, f func(T, T) T) T {
    acc := init
    for _, v := range s {
        acc = f(acc, v)
    }
    return acc
}

nums := []int{1, 2, 3, 4, 5, 6}
evens := Filter(nums, func(x int) bool { return x%2 == 0 })      // [2 4 6]
squared := Map(evens, func(x int) int { return x * x })          // [4 16 36]
sum := Reduce(squared, 0, func(a, b int) int { return a + b })  // 56
fmt.Println(sum)

Go 1.23+ 引入了 iter 包，提供 slices.Filter / slices.All 等迭代器函数（更新版本可用）。

8. 方法值 vs 方法表达式

type Point struct{ X, Y int }

func (p Point) Move(dx, dy int) Point {
    return Point{p.X + dx, p.Y + dy}
}

func main() {
    p := Point{1, 2}

    // 方法值：把方法绑给特定接收者
    mv := p.Move
    fmt.Println(mv(3, 4))  // {4 6}

    // 方法表达式：方法是第一个参数
    mv2 := Point.Move
    fmt.Println(mv2(p, 3, 4))  // {4 6}
}

9. 实战：手写一个 map 缓存

type Cache[K comparable, V any] struct {
    data map[K]V
    ttl  time.Duration
}

func NewCache[K comparable, V any](ttl time.Duration) *Cache[K, V] {
    return &Cache[K, V]{
        data: make(map[K]V),
        ttl:  ttl,
    }
}

func (c *Cache[K, V]) Set(k K, v V) {
    c.data[k] = v
    time.AfterFunc(c.ttl, func() {
        delete(c.data, k)
    })
}

func (c *Cache[K, V]) Get(k K) (V, bool) {
    v, ok := c.data[k]
    return v, ok
}

func main() {
    cache := NewCache[string, int](5 * time.Second)
    cache.Set("count", 42)
    if v, ok := cache.Get("count"); ok {
        fmt.Println("count =", v)
    }
}

小结

概念	关键点
多返回值	`(int, error)` 是惯用模式
命名返回值	文档化 + `defer` 里能修改
一等公民	函数可赋值/传参/返回/装容器
闭包	函数 + 引用环境；注意循环变量陷阱
defer	LIFO；用于资源清理；参数在 defer 时就求值
可变参数	`args ...Type`，传切片时用 `args...` 展开

最常用模式：

// 1. 错误返回
if err := doX(); err != nil { return err }

// 2. defer 清理
f, _ := os.Open(path)
defer f.Close()

// 3. 回调函数
type Handler func(req Request) Response

下一节讲错误处理与 panic/recover，这是 Go 区别于其他语言的关键设计。

本文作者： CoderSong
本文链接： https://jack-song-gif.github.io/2026/08/28/Go-05-函数、闭包与一等公民/
版权声明： 本博客所有文章除特别声明外，均采用 MIT 许可协议。转载请注明出处！