函数、多返回值与闭包

Go 函数的设计哲学：多返回值、闭包、defer——简洁而强大

一、函数定义

1.1 基本语法

// 格式：func 函数名(参数名 类型, ...) 返回类型
func add(a int, b int) int {
    return a + b
}

C++ 对照：

概念	C++	Go
函数定义	`int add(int a, int b)`	`func add(a int, b int) int`
类型位置	类型在前 `int a`	类型在后 `a int`
多返回值	`std::pair<T1,T2>` / `std::tuple`	直接返回 `(int, string)`
函数声明	头文件 + 源文件分离	同文件（包内导出靠大小写）

1.2 参数类型简写

相邻同类型参数可以合并：

// 两种写法等价
func calc(a int, b int, c int) int { ... }
func calc(a, b, c int) int { ... }  // 更简洁

1.3 没有默认参数，没有函数重载

Go 不支持默认参数和函数重载。需要类似效果时用函数选项模式或可变参数：

// 用 Option 模式替代默认参数（后面会详细讲）
type ServerOption struct {
    Addr string
    Port int
}

// 或者更简单的做法：拆成多个函数
func NewServer(addr string) *Server { ... }
func NewServerWithPort(addr string, port int) *Server { ... }

二、多返回值

这是 Go 最核心的设计之一，C++ 没有直接对应。

2.1 (T, error) 模式

import (
    "fmt"
    "strconv"
)

// Go 函数可以返回多个值
func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, fmt.Errorf("除数不能为零")
    }
    return a / b, nil
}

func main() {
    result, err := divide(10, 3)
    if err != nil {
        fmt.Println("错误:", err)
        return
    }
    fmt.Println("结果:", result) // 结果: 3.3333333333333335
}

2.2 C++ 对照

概念	C++	Go
多返回值	`std::pair<int, string>`	`(int, string)`
用 tuple	`std::tuple<int, bool, string>`	`(int, bool, string)`
错误处理	异常 `try/catch`	`(T, error)`
调用方必须处理	不强制	编译器要求全部处理或用 `_` 忽略

2.3 忽略不需要的返回值

// 只要第二个返回值
_, err := divide(10, 3)

// 只要第一个返回值（但编译器会报错，因为 error 未使用）
// 必须用 _ 显式忽略
result, _ := divide(10, 3)

重要：Go 编译器禁止声明了变量却不用。未使用的变量会导致编译错误（这是 Go 的强制编码规范）。

三、命名返回值

返回值可以有名字，这是 Go 特有的语法。

3.1 基本用法

// 命名返回值：返回值变量在函数签名中声明
func swap(a, b int) (x, y int) {
    x = b  // 直接赋值给命名返回值
    y = a
    return // bare return，自动返回 x, y
}

// 等价于
func swapExplicit(a, b int) (int, int) {
    return b, a  // 更清晰
}

3.2 bare return 的风险

// bare return 在短函数中简洁
func minMax(nums []int) (min, max int) {
    min, max = nums[0], nums[0]
    for _, v := range nums[1:] {
        if v < min { min = v }
        if v > max { max = v }
    }
    return  // 隐式返回 min, max
}

// 但在长函数中，bare return 会严重影响可读性
// Google Go 规范建议：只有短函数（不超过五行）才用 bare return

实践建议：大多数情况下，显式 return 更清晰。命名返回值主要用于文档和错误处理。

3.3 命名返回值 + 错误处理

func process(path string) (result string, err error) {
    // 命名返回值在这里的唯一好处：
    // defer 中可以直接修改 err
    defer func() {
        if r := recover(); r != nil {
            err = fmt.Errorf("panic recovered: %v", r)
        }
    }()

    data, err := os.ReadFile(path) // err 是命名返回值
    if err != nil {
        return "", err  // 也可以 return "", err（效果一样）
    }
    return string(data), nil
}

四、可变参数 (…T)

4.1 基本语法

// ...T 表示可变参数，函数内部当作切片处理
func sum(nums ...int) int {
    total := 0
    for _, n := range nums {
        total += n
    }
    return total
}

func main() {
    fmt.Println(sum(1, 2, 3))       // 6
    fmt.Println(sum(1, 2, 3, 4, 5)) // 15
}

4.2 展开切片传参

// 使用 nums... 展开切片传入可变参数函数
func main() {
    numbers := []int{1, 2, 3, 4, 5}
    fmt.Println(sum(numbers...)) // 6
}

4.3 C++ 对照

概念	C++	Go
可变参数	`template<typename... Args>`	`func f(args ...int)`
参数包展开	`f(args...)`	`f(args...)`
类型安全	模板保证	编译器保证（但只能是一种类型）

4.4 混合固定参数和可变参数

// 可变参数必须放在最后
func logMessage(level string, parts ...string) {
    msg := strings.Join(parts, " ")
    fmt.Printf("[%s] %s\n", level, msg)
}

func main() {
    logMessage("INFO", "user", "logged", "in")
    // [INFO] user logged in
}

五、函数作为值

Go 中函数是一等公民（first-class citizen），可以赋值、传参、返回。

5.1 赋值给变量

// 函数变量
var add = func(a, b int) int {
    return a + b
}

// 等价写法
add := func(a, b int) int {
    return a + b
}

fmt.Println(add(1, 2)) // 3

5.2 作为参数传递

// 接受函数作为参数
func apply(nums []int, fn func(int) int) []int {
    result := make([]int, len(nums))
    for i, v := range nums {
        result[i] = fn(v)
    }
    return result
}

func main() {
    nums := []int{1, 2, 3, 4, 5}

    // 传入匿名函数（类似 C++ 的 lambda）
    doubled := apply(nums, func(n int) int { return n * 2 })
    fmt.Println(doubled) // [2 4 6 8 10]

    // 传入命名函数
    squared := apply(nums, func(n int) int { return n * n })
    fmt.Println(squared) // [1 4 9 16 25]
}

5.3 作为返回值

// 返回一个函数（工厂模式）
func multiplier(factor int) func(int) int {
    return func(n int) int {
        return n * factor  // 闭包：捕获了 factor
    }
}

func main() {
    double := multiplier(2)
    triple := multiplier(3)

    fmt.Println(double(5))  // 10
    fmt.Println(triple(5))  // 15
}

5.4 C++ 对照

概念	C++	Go
函数指针	`int (*f)(int, int)`	`func(int, int) int`
std::function	`std::function<int(int,int)>`	`func(int, int) int`
Lambda	`[](int a, int b){ return a+b; }`	`func(a, b int) int { return a + b }`
捕获变量	`[x](int a){ return a+x; }`	闭包自动捕获

六、闭包

闭包 = 函数 + 它捕获的外部变量。Go 的闭包类似 C++ 的 lambda 表达式。

6.1 基本闭包

func counter() func() int {
    count := 0  // 外部变量
    return func() int {
        count++  // 捕获并修改外部变量
        return count
    }
}

func main() {
    c := counter()
    fmt.Println(c()) // 1
    fmt.Println(c()) // 2
    fmt.Println(c()) // 3
}

6.2 经典陷阱：循环变量捕获（Go 1.22 前）

// 旧版本（Go 1.22 前）的陷阱
func brokenFuncs() []func() {
    var funcs []func()
    for i := 0; i < 5; i++ {
        funcs = append(funcs, func() {
            fmt.Println(i)  // 捕获的是变量 i 的引用
        })
    }
    return funcs
}

// 旧版本中，所有函数都打印 5（循环结束后 i = 5）
// 因为闭包捕获的是变量 i 的引用，不是值的拷贝

Go 1.22+ 已修复：循环变量现在每次迭代都是新变量，闭包捕获的是当前值。

// Go 1.22+：循环变量每次迭代是独立的，不再有陷阱
func workingFuncs() []func() {
    var funcs []func()
    for i := 0; i < 5; i++ {
        funcs = append(funcs, func() {
            fmt.Println(i)  // Go 1.22+: 正确打印 0, 1, 2, 3, 4
        })
    }
    return funcs
}

6.3 如果需要兼容旧版本，显式拷贝

// 兼容 Go 1.22 前的写法：在循环体中创建局部变量
for i := 0; i < 5; i++ {
    i := i  // 重新声明局部变量，捕获的是拷贝
    funcs = append(funcs, func() {
        fmt.Println(i)
    })
}

6.4 C++ 对照

概念	C++	Go
Lambda 捕获	`[&x](int a){ return a+x; }`	`func(a int) int { return a+x }`
值捕获	`[x](int a){ return a+x; }`	不直接支持（需要在闭包前拷贝）
引用捕获	`[&x](int a){ x++; }`	默认行为（捕获变量引用）

七、defer

defer 是 Go 的资源清理机制，类似 C++ 的 RAII，但作用域不同。

7.1 基本用法

import "os"

func readFile(path string) (string, error) {
    file, err := os.Open(path)
    if err != nil {
        return "", err
    }
    defer file.Close()  // 函数退出时自动关闭文件

    // ... 读取文件 ...
    data := make([]byte, 100)
    n, err := file.Read(data)
    if err != nil {
        return "", err
    }
    return string(data[:n]), nil
}

7.2 defer 执行顺序（LIFO）

多个 defer 按声明的逆序执行，类似栈：

func main() {
    defer fmt.Println("第一个 defer")
    defer fmt.Println("第二个 defer")
    defer fmt.Println("第三个 defer")
    fmt.Println("正常执行")
}
// 输出：
// 正常执行
// 第三个 defer
// 第二个 defer
// 第一个 defer

7.3 关键陷阱：defer 参数在声明时求值

func main() {
    x := 10
    defer fmt.Println("defer 看到的 x =", x) // x 在声明时求值，不是退出时
    x = 20
    fmt.Println("当前 x =", x)
}
// 输出：
// 当前 x = 20
// defer 看到的 x = 10  <-- 注意：是 10，不是 20！

闭包方式可以避免此问题：

func main() {
    x := 10
    defer func() {
        fmt.Println("defer 看到的 x =", x) // 闭包捕获的是变量引用
    }()
    x = 20
}
// 输出：defer 看到的 x = 20  <-- 正确

7.4 C++ 对照

概念	C++	Go
资源清理	RAII（块级）	defer（函数级）
锁守卫	`std::lock_guard<std::mutex>`	`defer mu.Unlock()`
文件守卫	`std::fstream` 析构关闭	`defer f.Close()`
作用域	块 `{}` 退出时	函数退出时

7.5 defer vs RAII 的关键区别

func main() {
    if true {
        mu.Lock()
        defer mu.Unlock() // defer 在函数退出时执行，不是 if 块退出时
    }
    // 此处锁还没释放！因为 defer 要等 main 函数退出
    fmt.Println("锁还在")
}
// main 函数退出时，锁才释放

对比 C++：

void foo() {
    {
        std::lock_guard<std::mutex> lock(mu);
    }
    // 此处锁已释放！因为 lock_guard 在 {} 块退出时析构
}

八、方法不是函数

Go 的方法（method）和函数（function）看起来很像，但有一个关键区别：方法有 receiver。

8.1 方法定义

type Rectangle struct {
    Width  float64
    Height float64
}

// 方法：有 receiver（r Rectangle）
func (r Rectangle) Area() float64 {
    return r.Width * r.Height
}

// 函数：没有 receiver
func CalculateArea(w, h float64) float64 {
    return w * h
}

8.2 方法可以赋值给变量

func main() {
    rect := Rectangle{Width: 3, Height: 4}

    // 方法可以赋值给变量（变成函数值）
    areaFunc := rect.Area

    // 调用
    fmt.Println(areaFunc())       // 12
    fmt.Println(rect.Area())      // 12
    fmt.Println(CalculateArea(3, 4)) // 12
}

8.3 方法值 vs 方法表达式

type T struct{ Value int }

func (t T) Double() int { return t.Value * 2 }

func main() {
    t := T{Value: 5}

    // 方法值：绑定 receiver，直接调用
    f := t.Double
    fmt.Println(f()) // 10

    // 方法表达式：需要显式传 receiver
    g := T.Double
    fmt.Println(g(t)) // 10
}

九、综合示例

9.1 链式错误处理

import (
    "fmt"
    "os"
    "strconv"
)

// 典型的 Go 函数设计
func readAndConvert(path string) (int, error) {
    // 打开文件
    file, err := os.Open(path)
    if err != nil {
        return 0, fmt.Errorf("打开文件失败: %w", err) // %w 包装错误
    }
    defer file.Close() // 确保文件关闭

    // 读取内容（简化）
    buf := make([]byte, 100)
    n, err := file.Read(buf)
    if err != nil {
        return 0, fmt.Errorf("读取文件失败: %w", err)
    }

    // 转换为整数
    num, err := strconv.Atoi(string(buf[:n]))
    if err != nil {
        return 0, fmt.Errorf("转换整数失败: %w", err)
    }

    return num, nil
}

9.2 使用闭包实现装饰器

import "time"

// 装饰器：给函数添加日志
func withTiming(name string, fn func()) {
    start := time.Now()
    fn()
    fmt.Printf("%s 耗时: %v\n", name, time.Since(start))
}

// 实际使用
func main() {
    withTiming("排序", func() {
        // 排序逻辑...
        time.Sleep(100 * time.Millisecond)
    })
    // 排序 耗时: 100.xxx ms
}

十、常见坑

坑 1：defer 参数声明时求值

func main() {
    for i := 0; i < 3; i++ {
        defer fmt.Println(i) // 输出 2, 1, 0（不是 0, 1, 2）
    }
}
// defer 参数在声明时求值，i 的值在每次 defer 时就确定了
// 但执行顺序是逆序

坑 2：defer 在函数退出时执行（不是块退出时）

func main() {
    fmt.Println("开始")
    {
        defer fmt.Println("defer") // 这个 defer 要等 main 函数退出
    }
    fmt.Println("结束")
}
// 输出：开始, 结束, defer（不是 开始, defer, 结束）

坑 3：多返回值必须处理

func main() {
    result, err := divide(10, 3)

    // 编译错误：未使用变量
    // result

    // 正确做法：用 _ 忽略不需要的值
    result, _ = divide(10, 3)
    _ = result  // 或者完全不用变量
}

坑 4：命名返回值的误用

// 不推荐：过度使用 bare return
func process(x int) (result int, err error) {
    if x < 0 {
        err = errors.New("negative")
        return  // bare return，但不容易看出返回了什么
    }
    if x > 100 {
        return 0, errors.New("too large")  // 显式返回更清晰
    }
    result = x * 2
    return  // bare return
}
// 建议：除非函数很短，否则用显式 return

坑 5：defer 和 goroutine

func main() {
    go func() {
        defer fmt.Println("goroutine defer")
        fmt.Println("goroutine running")
    }()

    fmt.Println("main running")
    time.Sleep(time.Second)
}
// defer 只在所属的 goroutine 退出时执行，不影响其他 goroutine

十一、练习任务

写一个函数 Divide(a, b float64) (float64, error)，当除数为 0 时返回错误
写一个函数 Sum(nums ...int) int 支持任意数量的参数
实现一个计数器闭包 Counter() func() int，每次调用返回递增的值
实现一个 DeferDemo() 函数，验证 defer 的 LIFO 执行顺序
写一个函数 ApplyToEach(nums []int, fn func(int) int)，对切片中的每个元素应用函数
实现一个 Retry(n int, fn func() error) error 函数，失败时重试 n 次
用闭包实现一个简单的缓存函数 Cached(fn func(int) int) func(int) int

十二、本节要点速查

概念	要点
函数定义	`func name(参数名类型) 返回类型`，类型在后
多返回值	`(T, error)` 是 Go 标准错误处理模式
命名返回值	返回值有名字，可用 bare return，但不推荐过度使用
可变参数	`...T`，函数内部当作切片处理
函数作为值	赋值给变量、传参、返回，类似 C++ std::function
闭包	捕获外部变量，Go 1.22+ 循环变量不再有陷阱
defer	函数退出时逆序执行，用于资源清理，参数声明时求值
方法	有 receiver 的函数，可以赋值给变量
错误处理	`(T, error)` + `if err != nil` 是 Go 的核心模式

十三、参考资源

上一篇：05-map 下一篇：07-结构体与方法

一、函数定义#

1.1 基本语法#

1.2 参数类型简写#

1.3 没有默认参数，没有函数重载#

二、多返回值#

2.1 (T, error) 模式#

2.2 C++ 对照#

2.3 忽略不需要的返回值#

三、命名返回值#

3.1 基本用法#

3.2 bare return 的风险#

3.3 命名返回值 + 错误处理#

四、可变参数 (…T)#

4.1 基本语法#

4.2 展开切片传参#

4.3 C++ 对照#

4.4 混合固定参数和可变参数#

五、函数作为值#

5.1 赋值给变量#

5.2 作为参数传递#

5.3 作为返回值#

5.4 C++ 对照#

六、闭包#

6.1 基本闭包#

6.2 经典陷阱：循环变量捕获（Go 1.22 前）#

6.3 如果需要兼容旧版本，显式拷贝#

6.4 C++ 对照#

七、defer#

7.1 基本用法#

7.2 defer 执行顺序（LIFO）#

7.3 关键陷阱：defer 参数在声明时求值#

7.4 C++ 对照#

7.5 defer vs RAII 的关键区别#

八、方法不是函数#

8.1 方法定义#

8.2 方法可以赋值给变量#

8.3 方法值 vs 方法表达式#

九、综合示例#

9.1 链式错误处理#

9.2 使用闭包实现装饰器#

十、常见坑#

坑 1：defer 参数声明时求值#

坑 2：defer 在函数退出时执行（不是块退出时）#

坑 3：多返回值必须处理#

坑 4：命名返回值的误用#

坑 5：defer 和 goroutine#

十一、练习任务#

十二、本节要点速查#

十三、参考资源#