Golang 多返回值：(value, error) 与命名返回值

返回多个值

在圆括号中列出返回值类型。返回时用逗号分隔各个值，接收时也一样。

package main

import "fmt"

func minMax(xs []int) (int, int) {
	lo, hi := xs[0], xs[0]
	for _, x := range xs[1:] {
		lo = min(lo, x)
		hi = max(hi, x)
	}
	return lo, hi
}

func main() {
	lo, hi := minMax([]int{4, 9, 1, 7})
	fmt.Println("min:", lo, "max:", hi)
}

内置的 min 和 max 从 Go 1.21 起就有了。调用者必须接收所有返回值：x := minMax(nums) 无法编译，会报错 assignment mismatch: 1 variable but minMax returns 2 values。

(value, error) 约定

返回两个值最常见的原因是报告失败。按照约定，错误放在最后；当它不为 nil 时，其他返回值都应视为没有意义。

package main

import (
	"errors"
	"fmt"
	"strconv"
)

func parsePort(s string) (int, error) {
	n, err := strconv.Atoi(s)
	if err != nil {
		return 0, fmt.Errorf("port %q: %w", s, err)
	}
	if n < 1 || n > 65535 {
		return 0, errors.New("port out of range")
	}
	return n, nil
}

func main() {
	for _, in := range []string{"8080", "http", "70000"} {
		port, err := parsePort(in)
		if err != nil {
			fmt.Println("error:", err)
			continue
		}
		fmt.Println("port:", port)
	}
}

输出：

port: 8080
error: port "http": strconv.Atoi: parsing "http": invalid syntax
error: port out of range

失败时，其他所有返回值都返回零值（0、""、nil）。完整的模式，包括包装错误和检查错误，见错误处理页面。

comma-ok 惯用法

有几种内置操作会返回一个可选的第二个 bool 值，表示第一个值是否真实有效。这个变量按惯例命名为 ok。

package main

import "fmt"

func main() {
	ages := map[string]int{"ana": 31}

	age, ok := ages["bob"]
	fmt.Println(age, ok) // 0 false: missing key, not a zero age

	var v any = "hello"
	s, ok := v.(string)
	fmt.Println(s, ok)

	ch := make(chan int, 1)
	ch <- 5
	close(ch)
	x, ok := <-ch
	fmt.Println(x, ok) // 5 true: a buffered value is still delivered
	x, ok = <-ch
	fmt.Println(x, ok) // 0 false: closed and drained
}

这三种形式（map 查找、类型断言、通道接收）很特殊：它们返回一个值还是两个值，取决于你赋给几个变量。你自己的函数做不到这一点。声明了两个返回值的函数，总是返回两个值。

空白标识符

_ 接收一个值，然后把它丢掉。用它来接收你不需要的返回值：

_, err := fmt.Sscan(input, &n)
key, _ := parseLine(line)

用 _ 忽略错误能编译通过，所以只在你确定调用不会失败，或者失败也无所谓时才这样做。例如，strings.Builder.WriteString 总是返回 nil 错误；但写入后关闭文件就不是这样了。

命名返回值

返回值参数可以有名字。它们在函数开头声明，初始化为各自的零值，一个不带值的 return 会返回它们当前保存的值。

package main

import "fmt"

func split(total int) (quotient, remainder int) {
	quotient = total / 7
	remainder = total % 7
	return
}

func main() {
	weeks, days := split(45)
	fmt.Println(weeks, "weeks and", days, "days")
}

这些名字会出现在 go doc 的输出中，当两个返回值类型相同时尤其有用：(quotient, remainder int) 比 (int, int) 传达的信息更多。

在长函数中，裸 return 很难读，因为读者得往回翻才能知道返回值里装的是什么。通常的建议是：当名字能起到说明作用时就给返回值命名，但除非函数只有几行，否则仍然显式写出 return quotient, remainder。

命名返回值与 defer

defer 的函数在 return 语句设置好返回值之后、调用者收到它们之前运行。有了命名返回值，defer 的函数就可以读取和修改它们。借助这一点，你可以给函数返回的任何错误加上上下文，或者把 panic 转换成错误。

package main

import (
	"errors"
	"fmt"
)

func load(name string) (err error) {
	defer func() {
		if err != nil {
			err = fmt.Errorf("load %s: %w", name, err)
		}
	}()
	if name == "" {
		return errors.New("empty name")
	}
	return nil
}

func main() {
	fmt.Println(load(""))
	fmt.Println(load("config.json"))
}

这会先打印 load : empty name，再打印 <nil>。return errors.New(...) 先把值赋给 err，然后 defer 的函数再包装它。更多内容见 defer。

遮蔽命名返回值

命名返回值位于函数的最外层作用域。在嵌套块中使用 := 会创建一个同名的新变量，而裸 return 返回的是外层那个。

func find() (n int, err error) {
	if true {
		n, err := compute() // new n and err, shadowing the results
		_ = n
		_ = err
	}
	return // returns 0, nil
}

编译器能发现最糟糕的情况：在返回值被遮蔽的块内写裸 return，会报错 result parameter err not in scope at return。但它发现不了上面这种 return 位于块外的写法。当你指的是返回值变量时，用 = 而不是 :=。

常见错误

• 在 err 不为 nil 时使用返回的值。 先检查 err。函数在返回错误的同时，完全可以返回无意义的值。
• 把带类型的 nil 指针作为 error 返回。 var e *MyErr; return e 返回的是一个非 nil 的 error。成功时请返回字面量 nil。
• 返回值太多。 三个或更多含义各异的返回值很难使用。改为返回一个结构体。