GO语言基础教程（79）Go函数的返回值之返回多个值：Go函数竟然能一次返回多个值？！看完这篇别再只会用return了！

嘿，朋友们！今天咱们来聊聊Go语言里一个超级实用的特性——函数的多返回值。说真的，当我第一次发现Go函数可以一次返回多个值时，那感觉就像是发现新大陆一样兴奋！

为什么需要多返回值？

想象一下这个场景：你在写一个函数，需要同时返回计算结果和可能出现的错误。在只能返回单个值的语言里，你可能得绞尽脑汁——是返回一个结构体？还是通过指针参数来传递部分结果？啧啧，想想都头疼。

但是Go语言就很懂我们程序员的心，直接让你可以这样写：

func Divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, errors.New("除数不能为零")
    }
    return a / b, nil
}

看吧，干净利落！既返回了计算结果，又提供了错误信息，完美！

基础语法：怎么定义多返回值？

Go函数的多返回值语法简单到令人发指，就在函数声明的返回值部分多写几个类型就行了：

func 函数名(参数列表) (返回类型1, 返回类型2, ...) {
    // 函数体
}

来个实际例子热热身：

// 返回姓名和年龄
func GetUserInfo() (string, int) {
    return "张三", 25
}

func main() {
    name, age := GetUserInfo()
    fmt.Printf("姓名：%s，年龄：%d\n", name, age)
}

运行结果：

姓名：张三，年龄：25

就这么简单？对，就这么简单！但这里面其实有不少门道，听我慢慢道来。

命名返回值：让代码更清晰

Go还支持给返回值命名，这个特性跟多返回值搭配使用，效果简直绝配！

func Calculate(a, b int) (sum int, product int, difference int) {
    sum = a + b
    product = a * b
    difference = a - b
    return // 直接return，会自动返回已命名的变量
}

使用命名返回值的好处是什么呢？

代码可读性更强，从函数签名就知道每个返回值的含义
在函数体内直接赋值，return语句可以更简洁
特别是当返回值比较多的时候，这个优势就更明显了

错误处理：多返回值的杀手级应用

在Go语言中，错误处理的标准做法就是利用多返回值：

func ReadFile(filename string) ([]byte, error) {
    data, err := os.ReadFile(filename)
    if err != nil {
        return nil, fmt.Errorf("读取文件失败: %w", err)
    }
    return data, nil
}

这种模式在Go标准库中随处可见，已经成为Go语言的标志性写法。它让错误处理变得明确而优雅，再也不用像某些语言那样靠异常来传递错误了。

忽略不需要的返回值

有时候，你可能只关心部分返回值，这时候可以用下划线_来忽略不需要的值：

// 只关心结果，不关心错误
result, _ := Divide(10, 2)
fmt.Println("结果是：", result)

// 或者只关心错误
_, err := Divide(10, 0)
if err != nil {
    fmt.Println("出错了：", err)
}

不过要谨慎使用这个特性，特别是错误值，除非你确定不需要处理错误，否则最好还是检查一下。

实际应用场景

场景1：文件操作

func ProcessFile(path string) (content string, lineCount int, err error) {
    data, err := os.ReadFile(path)
    if err != nil {
        return "", 0, err
    }
    
    content = string(data)
    lines := strings.Split(content, "\n")
    lineCount = len(lines)
    
    return content, lineCount, nil
}

场景2：数据库查询

func GetUserByID(id int) (user User, exists bool, err error) {
    err = db.QueryRow("SELECT * FROM users WHERE id = ?", id).Scan(&user.ID, &user.Name, &user.Email)
    if err != nil {
        if err == sql.ErrNoRows {
            return User{}, false, nil
        }
        return User{}, false, err
    }
    return user, true, nil
}

场景3：并发编程

func ConcurrentFetch(urls []string) (results map[string]string, failedCount int) {
    results = make(map[string]string)
    var mutex sync.Mutex
    var wg sync.WaitGroup
    
    for _, url := range urls {
        wg.Add(1)
        go func(u string) {
            defer wg.Done()
            
            resp, err := http.Get(u)
            if err != nil {
                mutex.Lock()
                failedCount++
                mutex.Unlock()
                return
            }
            defer resp.Body.Close()
            
            body, _ := io.ReadAll(resp.Body)
            
            mutex.Lock()
            results[u] = string(body)
            mutex.Unlock()
        }(url)
    }
    
    wg.Wait()
    return results, failedCount
}

进阶技巧

交换变量值

多返回值让变量交换变得异常简单：

a, b = b, a // 不需要临时变量！

返回函数本身

你甚至可以返回函数：

func MakeMultiplier(factor int) (func(int) int, string) {
    multiplier := func(x int) int {
        return x * factor
    }
    description := fmt.Sprintf("乘以%d的函数", factor)
    return multiplier, description
}

// 使用
doubleFunc, desc := MakeMultiplier(2)
result := doubleFunc(5) // 返回10

注意事项和最佳实践

返回值数量要合理：虽然Go支持多返回值，但也不是越多越好。通常2-3个比较合适，太多了会影响代码可读性。
错误值的位置：按照Go的惯例，错误值通常是最后一个返回值。
文档化返回值：当返回多个值时，最好用注释说明每个返回值的含义。
考虑使用结构体：如果确实需要返回很多相关联的数据，考虑返回结构体可能更合适：

// 而不是这样：func GetUser() (string, int, string, error)
// 考虑这样：
type UserInfo struct {
    Name  string
    Age   int
    Email string
}

func GetUser() (UserInfo, error) {
    // ...
}

性能考虑

你可能会担心：返回多个值会影响性能吗？实际上，Go编译器很智能，多返回值在底层通常是通过栈来传递的，性能开销可以忽略不计。在大多数情况下，代码的清晰度和可维护性比这点微小的性能差异重要得多。

完整示例

来看一个综合性的例子，演示多返回值在实际项目中的应用：

package main

import (
    "fmt"
    "math"
    "strconv"
)

// 解析坐标字符串，返回x, y坐标和错误信息
func ParseCoordinate(coordStr string) (x, y float64, err error) {
    // 假设坐标格式为 "x,y"
    if coordStr == "" {
        return 0, 0, fmt.Errorf("坐标字符串不能为空")
    }
    
    // 简单的解析逻辑
    var xStr, yStr string
    for i, char := range coordStr {
        if char == ',' {
            xStr = coordStr[:i]
            yStr = coordStr[i+1:]
            break
        }
    }
    
    if xStr == "" || yStr == "" {
        return 0, 0, fmt.Errorf("坐标格式错误，应为 'x,y'")
    }
    
    x, err = strconv.ParseFloat(xStr, 64)
    if err != nil {
        return 0, 0, fmt.Errorf("x坐标解析错误: %w", err)
    }
    
    y, err = strconv.ParseFloat(yStr, 64)
    if err != nil {
        return 0, 0, fmt.Errorf("y坐标解析错误: %w", err)
    }
    
    return x, y, nil
}

// 计算两点之间的距离和中点
func CalculatePoints(p1x, p1y, p2x, p2y float64) (distance, midX, midY float64) {
    distance = math.Sqrt(math.Pow(p2x-p1x, 2) + math.Pow(p2y-p1y, 2))
    midX = (p1x + p2x) / 2
    midY = (p1y + p2y) / 2
    return
}

func main() {
    // 示例1：解析坐标
    x1, y1, err := ParseCoordinate("3.5,4.2")
    if err != nil {
        fmt.Println("错误:", err)
        return
    }
    
    x2, y2, err := ParseCoordinate("7.8,9.1")
    if err != nil {
        fmt.Println("错误:", err)
        return
    }
    
    fmt.Printf("点1: (%.2f, %.2f)\n", x1, y1)
    fmt.Printf("点2: (%.2f, %.2f)\n", x2, y2)
    
    // 示例2：计算距离和中点
    dist, midX, midY := CalculatePoints(x1, y1, x2, y2)
    fmt.Printf("两点距离: %.2f\n", dist)
    fmt.Printf("中点坐标: (%.2f, %.2f)\n", midX, midY)
    
    // 示例3：忽略部分返回值
    _, justMidX, justMidY := CalculatePoints(x1, y1, x2, y2)
    fmt.Printf("只关心中点: (%.2f, %.2f)\n", justMidX, justMidY)
}

运行结果：

点1: (3.50, 4.20)
点2: (7.80, 9.10)
两点距离: 6.10
中点坐标: (5.65, 6.65)
只关心中点: (5.65, 6.65)

总结

Go函数的多返回值特性虽然看起来简单，但实际用起来却是相当给力。它让我们的代码更加清晰、错误处理更加优雅、API设计更加合理。从简单的数据返回到复杂的错误处理，这个特性在Go语言的各个角落都发挥着重要作用。

记住，好的工具要用在合适的地方。多返回值虽好，但也不要滥用。当返回值确实相关且经常一起使用时，多返回值是个好选择；当数据比较复杂时，考虑使用结构体可能更合适。

现在，就去你的Go项目里试试多返回值吧，相信你会爱上这个特性的！