golang：接口和类型之间的转换

落日映苍穹つ 2022-02-25 04:47 477阅读 0赞

golang中使用接口断言将接口转换成另一个接口，也可以将接口转换成另外的类型。

# 类型断言格式 #

类型断言是一个使用在接口值上的操作。语法上它看起来像 i.(T) 被称为断言类型，这里 i 表示一个接口的类型和 T 表示一个类型。一个类型断言检查它操作对象的动态类型是否和断言的类型匹配。

类型断言的基本格式如下：

t := i.(T)

其中，i 代表接口变量，T 代表转换的目标类型，t 代表转换后的变量。

这里有两种可能。

*  第一种，如果断言的类型 T 是一个具体类型，然后类型断言检查 i 的动态类型是否和 T 相同。
    
     *  如果这个检查成功了，类型断言的结果是 i 的动态值，当然它的类型是 T。换句话说，具体类型的类型断言从它的操作对象中获得具体的值。
     *  如果检查失败，接下来这个操作会抛出 panic。

例如：

var w io.Writer
    w = os.Stdout
    f := w.(*os.File) // 成功: f == os.Stdout
    c := w.(*bytes.Buffer) // 死机：接口保存*os.file，而不是*bytes.buffer

*  第二种，如果相反断言的类型 T 是一个接口类型，然后类型断言检查是否 i 的动态类型满足 T。
    
     *  如果这个检查成功了，动态值没有获取到；这个结果仍然是一个有相同类型和值部分的接口值，但是结果有类型 T。
     *  换句话说，对一个接口类型的类型断言改变了类型的表述方式，改变了可以获取的方法集合（通常更大），但是它保护了接口值内部的动态类型和值的部分。

在下面的第一个类型断言后，w 和 rw 都持有 os.Stdout 因此它们每个有一个动态类型 \*os.File，但是变量 w 是一个 io.Writer 类型只对外公开出文件的 Write 方法，然而 rw 变量也只公开它的 Read 方法。

var w io.Writer
    w = os.Stdout
    rw := w.(io.ReadWriter) // 成功：*os.file具有读写功能
    w = new(ByteCounter)
    rw = w.(io.ReadWriter) // 死机：*字节计数器没有读取方法

如果断言操作的对象是一个 nil 接口值，那么不论被断言的类型是什么这个类型断言都会失败。几乎不需要对一个更少限制性的接口类型（更少的方法集合）做断言，因为它表现的就像赋值操作一样，除了对于 nil 接口值的情况。

如果 i 没有完全实现 T 接口的方法，这个语句将会触发宕机。触发宕机不是很友好，因此上面的语句还有一种写法：

t,ok := i.(T)

这种写法下，如果发生接口未实现时，将会把 ok 置为 false，t 置为 T 类型的 0 值。正常实现时，ok 为 true。这里 ok 可以被认为是：i 接口是否实现 T 类型的结果。

# 将接口转换为其他接口 #

实现某个接口的类型同时实现了另外一个接口，此时可以在两个接口间转换

package main
    import "fmt"
    // 定义飞行动物接口
    type Flyer interface {
        
        Fly()
    }
    // 定义行走动物接口
    type Walker interface {
        
        Walk()
    }
    // 定义鸟类
    type bird struct {
        
    }
    // 实现飞行动物接口
    func (b *bird) Fly() {
        
        fmt.Println("bird: fly")
    }
    // 为鸟添加Walk()方法, 实现行走动物接口
    func (b *bird) Walk() {
        
        fmt.Println("bird: walk")
    }
    // 定义猪
    type pig struct {
        
    }
    // 为猪添加Walk()方法, 实现行走动物接口
    func (p *pig) Walk() {
        
        fmt.Println("pig: walk")
    }
    func main() {
        
    // 创建动物的名字到实例的映射
        animals := map[string]interface{
        }{
        
            "bird": new(bird),
            "pig":  new(pig),
        }
        // 遍历映射
        for name, obj := range animals {
        
            // 判断对象是否为飞行动物
            f, isFlyer := obj.(Flyer)
            // 判断对象是否为行走动物
            w, isWalker := obj.(Walker)
            fmt.Printf("name: %s isFlyer: %v isWalker: %v\n", name, isFlyer, isWalker)
            // 如果是飞行动物则调用飞行动物接口
            if isFlyer {
        
                f.Fly()
            }
            // 如果是行走动物则调用行走动物接口
            if isWalker {
        
                w.Walk()
            }
        }
    }

# 将接口转换为其他类型 #

可以实现将接口转换为普通的指针类型。例如将上面 Walker 接口转换为 \*pig 类型，请参考下面的代码：

p1 := new(pig)
    var a Walker = p1
    p2 := a.(*pig)
    fmt.Printf("p1=%p p2=%p", p1, p2)

如果尝试将上面这段代码中的 Walker 类型的 a 转换为 \*bird 类型，将会发出运行时错误，请参考下面的代码：

p1 := new(pig)
    var a Walker = p1
    p2 := a.(*bird)

# 总结 #

接口和其他类型的转换可以在Go语言中自由进行，前提是已经完全实现。

接口断言类似于流程控制中的 if。但大量类型断言出现时，应使用更为高效的类型分支 switch 特性。