go语言的类型断言(Type Assertion)

x.(T) 检查x的动态类型是否是T,其中x必须是接口值。

  • 如果T是具体类型
    类型断言检查x的动态类型是否等于具体类型T。如果检查成功,类型断言返回的结果是x的动态值,其类型是T。换句话说,对接口值x断言其动态类型是具体类型T,若成功则提取出x的具体值。如果检查失败则panic。
    例如:
var w io.Writer
w = os.Stdout  //os.Stdout是一个类型为*os.File的包级别变量
f := w.(*os.File) //断言接口w的动态类型是具体类型*os.File,断言成功,返回os.Stdout给f
c := w.(*bytes.Buffer) //断言接口w的动态类型是具体类型*bytes.Buffer,断言失败,panic
  • 如果T是接口类型
    类型断言检查x的动态类型是否满足T。如果检查成功,x的动态值不会被提取,返回值是一个类型为T的接口值。换句话说,到接口类型的类型断言,改变了表达式的类型,改变了(通常是扩大了)可以访问的方法,且保护了接口值内部的动态类型和值。
    例如:
var w io.Writer
w = os.Stdout
rw := w.(io.ReadWriter) //成功:*os.File同时有Read和Write方法
w = new(ByteCounter)  //有Write方法
rw = w.(io.ReadWriter) // panic: *ByteCounter没有Read方法
  • 无论T是什么类型,如果x是nil接口值,则类型断言失败。
  • 类型断言到一个较少限制(较少方法)的接口类型基本是不需要的,因为这个行为和赋值一样(除了nil的情况):
w = rw // io.ReadWriter赋值给io.Writer
w = rw.(io.Writer) //和上面一样,仅当rw为nil时失败,而上面如果rw为nil则w被赋值为nil

如果我们想知道类型断言是否失败,而不是失败时触发panic,可以使用返回两个值的版本:

y, ok := x.(T)

当检查成功时ok为true。例如:

var w io.Writer = os.Stdout
f, ok := w.(*os.File) //成功:f为os.Stdout,ok为true
b, ok := w.(*bytes.Buffer) //失败:b为零值,这里是nil, ok为false,no panic

ok值通常立刻用于决定是否执行下一步,惯用法:

if f, ok := w.(*os.File); ok {
    // ... use f ...
}

类型断言用于查询可能的行为,例子:

package main

import (
    "io"
    "os"
)

//这个例子展示了类型断言用于选择可能的行为,这儿如果一个io.Writer支持WriteString则可以直接使用,从而避免分配临时内存

func writeString(w io.Writer, s string) (n int, err error) {
    type stringWriter interface {
        WriteString(string) (n int, err error)
    }
    if sw, ok := w.(stringWriter); ok {
        //fmt.Print("<use WriteString>")
        return sw.WriteString(s) // avoid temporary copy
    }
    return w.Write([]byte(s)) // allocate temporary copy
}

func writeHeader(w io.Writer, contentType string) error {
    if _, err := writeString(w, "Content-Type: "); err != nil {
        return err
    }
    if _, err := io.WriteString(w, contentType); err != nil { //系统自带的io.WriteString实现和上面一样
        return err
    }
    return nil
}

func main() {
    writeHeader(os.Stdout, "test")
}
  • 接口值可有包含各种不同的具体类型值,而类型断言就是用于从接口中动态的区分出各种具体的类型,从而可以使用具体的类型。
  • Type Switches
switch x.(type){
case nil: // 如果x是nil
case int, uint: 
case bool:
case string;
default: //没有匹配上
}
//case的顺序是有意义的,因为可能同时满足多个接口,不可以用fallthrough, default的位置无所谓。

如果需要提取具体的值:

switch x := x.(type) { /* ... */  } //前面的x是一个局部变量,因为switch创建了一个词法域
//x的类型就是每个case的类型,如果case有多个类型,则类型为interface{}
    原文作者:勤奋happyfire
    原文地址: https://www.jianshu.com/p/6a46fc7b6e5b
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞