函数基础：多返回值、命名返回值与可变参数

一、学习目标

二、知识讲解

6.1 函数签名与多返回值

是什么 在 Go 语言中，函数是代码复用的基本单元。函数的签名（Signature）由参数列表的类型和返回值列表的类型决定，函数名不属于签名。这意味着，如果两个函数参数类型和返回值类型完全相同，即使函数名不同，它们在类型系统中也是兼容的（尽管不能在同一作用域内重复声明同名函数）。

Go 函数最显著的特征之一是支持多返回值。这与许多其他语言（如 C/C++、Java）不同，后者通常只能通过返回结构体或指针来模拟多返回值，或者依赖全局变量/输出参数。

为什么这样设计 1. 错误处理：Go 推崇显式错误处理。函数可以同时返回结果和错误对象，调用者可以清晰地检查错误，而无需依赖异常机制。 2. 简洁性：避免了为了返回多个值而创建临时结构体的样板代码。

怎么用 声明多返回值函数时，返回值列表可以写在括号内。如果只有一个返回值，括号可以省略；如果有多个，必须使用括号。

// 语法示例
func functionName(params) (result1 Type1, result2 Type2) {
    // 函数体
}

6.2 命名返回值与 return 的细节

是什么 Go 允许在函数签名中为返回值指定名称，这称为命名返回值（Named Return Values）。

为什么这样设计 1. 文档化：返回值名称本身就是一种文档，让调用者一眼看出返回值的含义。 2. 简化裸 return：当函数使用命名返回值时，return 语句可以不带任何参数（称为裸 return），Go 会自动返回当前各命名返回变量的值。

关键细节：裸 return 与 defer 裸 return 返回的是执行到 return 语句时各命名返回值的当前值，而不是函数被调用时的快照值。这一特性与 defer 结合时非常强大：defer 语句中修改命名返回值，会影响最终返回给调用者的结果。

注意：该行为在 Go 1.22 之前也是稳定的，但需注意模块声明。

怎么用

func divide(a, b int) (quotient int, err error) {
    if b == 0 {
        err = errors.New("division by zero")
        return // 返回 err 的当前值（已赋值）和 quotient 的零值
    }
    quotient = a / b
    return // 返回 quotient 和 err 的当前值
}

6.3 变参函数

是什么 变参（Variadic parameters）允许函数接收零个或多个相同类型的参数。在函数签名中，变参通过 ...Type 表示。

为什么这样设计 在处理不定数量的参数时（如日志记录、格式化输出），变参提供了极大的灵活性，避免了重载函数或传递切片带来的繁琐。

怎么用 在函数内部，变参参数被视为一个切片（[]Type）。在调用变参函数时，如果传入的是一个切片，必须使用 ... 操作符将其展开。

注意：fmt.Printf 的签名是 func Printf(format string, a ...any) (n int, err error)。

6.4 函数类型与闭包初识

是什么 在 Go 中，函数是一等公民（First-class citizen）。你可以定义函数类型（Function Type），并将函数赋值给变量、作为参数传递或作为返回值返回。

闭包（Closure）是指一个函数值，它引用了在其函数体之外声明的变量。闭包使得函数可以“捕获”并访问其定义时的环境。

defer 与闭包的求值时机 defer 语句执行时，被调用函数的函数值与全部实参都会立即求值并保存，真正被推迟到函数返回时的是这一次调用。 - 如果实参是值类型（如 i），defer 保存的是当时的值。 - 如果实参是函数类型（闭包），闭包表达式本身在 defer 处求值（捕获当时的变量引用），但闭包体内的代码直到函数返回时才执行。

注意：Go 1.22 起，for 循环变量在每次迭代中都是新的，这影响了闭包捕获变量的行为。该变更依据模块 go.mod 的 go 指令生效：只有声明 go 1.22+ 的模块才启用新语义。

三、示例代码

示例 1：多返回值、命名返回值与 defer 的交互

这个示例演示了如何使用命名返回值，以及 defer 如何修改最终返回的命名返回值。

package main

import (
    "fmt"
)

// modifyResult 演示命名返回值与 defer 的交互：返回一个计算结果和一个状态字符串
func modifyResult(x int) (result int, status string) {
    // 命名返回值初始化为零值：result=0, status=""

    // 计算结果
    result = x * 2

    // 设置初始状态
    status = "initial"

    // defer 会在函数返回前执行
    // 注意：defer 语句执行时，实参（如果有的话）会求值，
    // 但这里我们直接修改命名返回值 status
    defer func() {
        status = "defer-modified"
    }()

    // 裸 return 返回当前 result 和 status 的值
    // 此时 status 已被 defer 中的匿名函数修改
    return
}

func main() {
    res, st := modifyResult(10)
    fmt.Printf("Result: %d, Status: %s\n", res, st)
}

运行结果（预期输出）：

Result: 20, Status: defer-modified

示例 2：变参函数与函数类型

这个示例演示了变参函数的使用、切片展开，以及函数作为类型的使用。

package main

import (
    "fmt"
    "strings"
)

// sum 演示变参函数
// 在函数内部，nums 的类型是 []int
func sum(nums ...int) int {
    total := 0
    for _, num := range nums {
        total += num
    }
    return total
}

// applyFunc 演示函数类型作为参数
// 接受一个函数类型 f，并传入一个 int 参数
func applyFunc(f func(int) int, x int) int {
    return f(x)
}

func main() {
    // 1. 变参调用：直接传入多个参数
    fmt.Println("Sum of 1, 2, 3:", sum(1, 2, 3))

    // 2. 变参调用：传入切片
    // strings.Join 接收 []string（正是变参在函数内部的形态），因此这里直接传 parts 无需 ...
    parts := []string{"Go", "is", "awesome"}
    fmt.Println("Joined:", strings.Join(parts, " "))

    // 3. 函数类型：定义一个函数变量
    square := func(x int) int {
        return x * x
    }

    // 4. 将函数作为参数传递
    fmt.Println("Square of 5:", applyFunc(square, 5))
}

运行结果（预期输出）：

Sum of 1, 2, 3: 6
Joined: Go is awesome
Square of 5: 25

四、常见错误与避坑指南

五、最佳实践

六、练习题

1. 概念题 在 Go 中，函数签名由哪些部分组成？函数名是否属于函数签名？

2. 编码题 编写一个函数 processData，它接收一个整数切片和一个处理函数（func(int) int），返回一个新的切片，其中每个元素都是原元素经过处理函数处理后的结果。

3. 进阶/调试题 以下代码在 Go 1.21 及更早版本（或 go.mod 声明 go < 1.22 的模块）中行为不符合预期。请找出问题并修复，确保输出为 0 1 2 3 4（顺序可能因调度而不同，但值必须正确）。

```go package main

import ( "fmt" "sync" )

func main() { var wg sync.WaitGroup for i := 0; i < 5; i++ { wg.Add(1) go func() { defer wg.Done() fmt.Print(i, " ") }() } wg.Wait() } ```

七、练习参考答案

package main

import "fmt"

// processData 接收一个整数切片和一个处理函数，返回处理后的新切片
func processData(nums []int, f func(int) int) []int {
    result := make([]int, len(nums))
    for i, num := range nums {
        result[i] = f(num)
    }
    return result
}

func main() {
    nums := []int{1, 2, 3, 4, 5}
    // 使用匿名函数作为处理函数，将每个元素乘以 2
    doubled := processData(nums, func(x int) int {
        return x * 2
    })
    fmt.Println(doubled) // 输出: [2 4 6 8 10]
}

package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup
    for i := 0; i < 5; i++ {
        wg.Add(1)
        // 修复：将 i 作为参数传递给 goroutine，确保每个 goroutine 捕获的是当前迭代的值
        go func(val int) {
            defer wg.Done()
            fmt.Print(val, " ")
        }(i)
    }
    wg.Wait()
    fmt.Println() // 换行
}

八、本课小结