Golang 类型断言：x.(T)、comma-ok 与类型 switch

x.(T)：从接口中取出值

接口值隐藏了它所持有的具体类型。类型断言 x.(T) 用来把它取回来。

package main

import "fmt"

func main() {
	var v any = "gopher"

	s := v.(string) // v holds a string: ok
	fmt.Println(s, len(s))

	n, ok := v.(int) // comma-ok: no panic on mismatch
	fmt.Println(n, ok)

	if str, ok := v.(string); ok {
		fmt.Println("string of length", len(str))
	}
}

输出：

gopher 6
0 false
string of length 6

x 必须是接口类型。对具体类型做断言无法编译：invalid operation: s (variable of type string) is not an interface。

单返回值形式会 panic

断言错误时，单返回值形式会 panic，信息中会写明两个类型：

package main

import "fmt"

func main() {
	defer func() {
		fmt.Println("recovered:", recover())
	}()

	var v any = 42
	s := v.(string)
	fmt.Println(s)
}

输出：

recovered: interface conversion: interface {} is int, not string

只有当出现其他类型属于程序错误、你希望程序直接崩溃时，才用单返回值形式。其他情况都用 comma-ok。失败时，comma-ok 返回 T 的零值和 false。

对 nil 接口做断言也会失败：var v any; v.(string) 会 panic，信息为 interface conversion: interface {} is nil, not string，而 comma-ok 形式返回 "", false。

断言为另一个接口

T 也可以是接口类型。这时只要动态值实现了 T，断言就会成功，结果保留同一个动态值。标准库就是用这种方式检查可选能力的。

package main

import (
	"fmt"
	"strings"
)

type Temp float64

func (t Temp) String() string { return fmt.Sprintf("%.1f degrees", float64(t)) }

func describe(v any) string {
	if s, ok := v.(fmt.Stringer); ok {
		return "Stringer: " + s.String()
	}
	return fmt.Sprintf("plain value: %v", v)
}

func main() {
	fmt.Println(describe(Temp(21.5)))
	fmt.Println(describe(42))

	// io.Copy uses the same trick to check for WriterTo / ReaderFrom.
	var r any = strings.NewReader("x")
	_, hasLen := r.(interface{ Len() int })
	fmt.Println("has Len:", hasLen)
}

io.Copy 会检查它的数据源是否实现了 io.WriterTo，如果实现了就使用它。fmt 会检查 Stringer 和 error。这种模式让小接口保持小巧，调用方同时还能受益于功能更丰富的实现。

类型 switch

当一个值可能是几种类型之一时，类型 switch 可以替代一连串的断言。x.(type) 只能在 switch 内部使用。

package main

import (
	"fmt"
	"strconv"
)

func toString(v any) string {
	switch x := v.(type) {
	case nil:
		return "nil"
	case string:
		return x // x is a string here
	case int, int64:
		return fmt.Sprintf("integer %v", x) // x is any: two types in one case
	case float64:
		return strconv.FormatFloat(x, 'f', 2, 64)
	case fmt.Stringer:
		return x.String()
	case error:
		return "error: " + x.Error()
	default:
		return fmt.Sprintf("unhandled %T", x)
	}
}

func main() {
	values := []any{"hi", 7, int64(8), 3.14159, nil, fmt.Errorf("boom"), []int{1}}
	for _, v := range values {
		fmt.Println(toString(v))
	}
}

输出：

hi
integer 7
integer 8
3.14
nil
error: boom
unhandled []int

值得了解的规则：

• 在只有一个类型的 case 中，x 就是那个类型。在列出多个类型的 case 和 default 中，x 是原接口的类型（这里是 any）。
• case 按顺序检查。一个值可能同时满足多个接口，所以把更具体的接口放在更宽泛的接口之前。
• case nil 只匹配 nil 接口，不匹配持有 nil 指针的接口。
• 类型 switch 中没有 fallthrough。

errors.As：针对被包装错误的断言

错误常常会被加上上下文后包装起来：fmt.Errorf("load config: %w", err)。直接的类型断言只看最外层的错误，会漏掉里面的那个。errors.As 会沿着包装链查找。

package main

import (
	"errors"
	"fmt"
	"io/fs"
	"os"
)

func load() error {
	_, err := os.Open("/no/such/file")
	if err != nil {
		return fmt.Errorf("load config: %w", err)
	}
	return nil
}

func main() {
	err := load()

	_, ok := err.(*fs.PathError)
	fmt.Println("type assertion finds it:", ok)

	var pe *fs.PathError
	if errors.As(err, &pe) {
		fmt.Println("errors.As finds it:", pe.Op, pe.Path)
	}
}

输出：

type assertion finds it: false
errors.As finds it: open /no/such/file

只有在确定错误没有被包装时才对错误使用类型断言，而实际上这种情况几乎没有。自定义错误一节介绍了 errors.As、errors.Is 以及如何定义自己的错误类型。

断言、转换与泛型

满是 any 和类型 switch 的代码，往往说明用泛型或合适的接口能更好地表达意图，并在编译时发现错误。

常见错误

• 对不可信的数据使用会 panic 的形式。 解码后的 JSON、类型为 any 的 map 值、插件的输入：一律用 comma-ok。
• 断言成了错误的数值类型。 JSON 数字解码到 any 时是 float64，所以对它们执行 v.(int) 会失败。
• 存的是指针，却断言成值类型。 如果接口中存的是 *User，那么 v.(User) 会失败。请断言 v.(*User)。
• 对错误使用类型断言。 请用 errors.As。