42. 接口值与类型断言

本节目标：搞懂接口值内部长什么样，学会用类型断言从接口里取出具体类型的值。

接口值的内部结构

一个接口变量内部包含两部分：

类型信息（动态类型）：当前存的是什么类型
值信息（动态值）：当前存的具体值

可以理解成一个元组 (type, value)：

package main

import "fmt"

type Speaker interface {
    Speak() string
}

type Dog struct{ Name string }

func (d Dog) Speak() string {
    return d.Name + ": 汪汪"
}

func main() {
    var s Speaker       // 接口变量，此时 (nil, nil)
    fmt.Println(s)      // <nil>

    s = Dog{Name: "Rex"} // 现在 (Dog, {Rex})
    fmt.Println(s)       // {Rex}

    fmt.Printf("%T\n", s) // Dog  动态类型
}

Note

接口变量声明时是 nil，表示 (type=nil, value=nil)。一旦赋了值，type 和 value 都不为 nil。

nil 接口 vs 含 nil 值的接口

这是 Go 里最隐蔽的坑之一：

package main

import "fmt"

type MyError struct{}

func (e *MyError) Error() string {
    return "出错了"
}

func doSomething() error {
    var err *MyError = nil
    return err // 返回的是 error 接口
}

func main() {
    err := doSomething()
    fmt.Println(err == nil) // false!
}

doSomething 返回了一个 nil 指针，但赋值给 error 接口后，接口值变成了 (*MyError, nil)。类型信息不是 nil，所以整个接口不等于 nil。

Warning

函数返回接口类型时，如果返回的是 nil 具体类型指针，接口 != nil。这是 Go 最常见的 bug 之一。解决办法是直接返回 nil：

func doSomething() error {
    var err *MyError = nil
    if /* 出错 */ {
        err = &MyError{}
        return err
    }
    return nil // 直接返回 nil，不要返回 nil 指针
}

类型断言

类型断言是从接口值里取出具体类型的值。语法是 x.(T)：

package main

import "fmt"

type Speaker interface {
    Speak() string
}

type Dog struct{ Name string }
func (d Dog) Speak() string { return "汪汪" }

func main() {
    var s Speaker = Dog{Name: "Rex"}

    // 类型断言：取出 Dog 类型
    d := s.(Dog)
    fmt.Println(d.Name) // Rex
}

逗号 ok 模式

如果断言的类型不对，直接断言会 panic。用逗号 ok 模式可以安全断言：

var s Speaker = Dog{Name: "Rex"}

// 安全断言
d, ok := s.(Dog)
fmt.Println(ok, d.Name) // true Rex

// 断言成不存在的类型
c, ok := s.(Cat) // 假设 Cat 也存在
fmt.Println(ok)   // false  不会 panic

Tip

永远用逗号 ok 模式做类型断言，除非你 100% 确定类型是对的。不加 ok 的断言一旦失败就 panic，生产环境很危险。

类型断言的实际用途

检查是否实现了某个接口

package main

import "fmt"

type Stringer interface {
    String() string
}

func describe(v any) {
    if s, ok := v.(Stringer); ok {
        fmt.Println("实现了Stringer:", s.String())
    } else {
        fmt.Println("没实现Stringer")
    }
}

type Person struct{ Name string }
func (p Person) String() string { return "Person: " + p.Name }

func main() {
    describe(Person{Name: "Alice"}) // 实现了Stringer: Person: Alice
    describe(42)                     // 没实现Stringer
}

从接口取出具体数据

在处理 JSON、HTTP 请求等场景时，经常拿到 any 类型的数据，需要断言成具体类型：

package main

import "fmt"

func process(data any) {
    switch v := data.(type) {
    case string:
        fmt.Println("字符串:", v)
    case int:
        fmt.Println("整数:", v)
    case []any:
        fmt.Println("数组，长度:", len(v))
    default:
        fmt.Println("未知类型")
    }
}

func main() {
    process("hello")     // 字符串: hello
    process(42)          // 整数: 42
    process([]any{1, 2}) // 数组，长度: 2
}

Note

上面用的 data.(type) 是类型 switch 语法，下一章会专门讲。

接口值的赋值规则

接口变量能存什么值？只要值的类型实现了接口的所有方法就行：

type Speaker interface {
    Speak() string
}

type Dog struct{}
func (d Dog) Speak() string { return "汪汪" }

type Cat struct{}
func (c *Cat) Speak() string { return "喵喵" }

func main() {
    var s Speaker

    s = Dog{}   // OK：Dog 实现了 Speak（值接收者）
    s.Speak()

    s = &Cat{}  // OK：*Cat 实现了 Speak（指针接收者）
    s.Speak()

    // s = Cat{}  // 编译错误！Cat 没有实现 Speak，*Cat 才有
}

Warning

如果 Speak 的接收者是 *Cat（指针接收者），那只有 *Cat 满足 Speaker 接口，Cat（值）不满足。这是方法集规则决定的，上一章讲过。

小结

接口值和类型断言的要点：

接口值 = (类型, 值) 两部分
nil 接口和含 nil 值的接口不同，这是常见 bug 源
用 x.(T) 做类型断言，加逗号 ok 避免 panic
值接收者：值和指针都满足接口；指针接收者：只有指针满足

下一章讲类型 switch，处理多种类型的优雅方式。