关于golang:ingerface类型转换总结

goLang 的 interface{}功能强大，能够指向各种类型数据，在数据类型转换之间能够有以下几种办法

有如下定义

type BaseService struct {
    IService
    serviceName string
    routineNum  int
}

type MyEnum int

const (
    CAT MyEnum = iota
    DOG
)

var unknowValue interface{}

unknowValue = baseService

办法 1: 应用断言的形式
如下的形式
originalValue, ok := unknowValue.(OriginalType)

val, ok := unknowValue.(BaseService)

if ok {fmt.Println(val)
}

这种形式简略，没什么可说的，间接转换成你想要的类型

办法 2: 应用反射
能够应用反射的 reflect.TypeOf(unknowValue)也能够是用 reflect.ValueOf(unknowValue)

typeOfUnknown := reflect.TypeOf(unknowValue)
fmt.Printf("%v, %v\n", typeOfUnknown.Name(), typeOfUnknown.Kind())

unknowValue = "123"
typeOfUnknown = reflect.TypeOf(unknowValue)
fmt.Printf("%v, %v\n", typeOfUnknown.Name(), typeOfUnknown.Kind())

unknowValue = 123
typeOfUnknown = reflect.TypeOf(unknowValue)
fmt.Printf("%v, %v\n", typeOfUnknown.Name(), typeOfUnknown.Kind())

输入后果为

BaseService, struct
MyEnum, int
string, string
int, int

func showKind(typeOfUnknown interface{}) {vv := reflect.ValueOf(typeOfUnknown)

    switch vv.Kind() {
    case reflect.String:
        fmt.Println("string")
    case reflect.Int:
        fmt.Println("int")
        fmt.Println(vv.Type().Name())
    case reflect.Struct:
        fmt.Println("Struct")
        fmt.Println(vv.Type().Name())
    }
}

后果高深莫测
对于 struct 类型，Kind 是 struct，Name 是理论的构造体名
对于自定义类型，Kind 是理论的类型，Name 是自定义的名称
对于根底数据类型，Kind 就是理论的类型。

goLang 的所有 Kind 如下

type Kind uint
const (
    Invalid Kind = iota  // 非法类型
    Bool                 // 布尔型
    Int                  // 有符号整型
    Int8                 // 有符号 8 位整型
    Int16                // 有符号 16 位整型
    Int32                // 有符号 32 位整型
    Int64                // 有符号 64 位整型
    Uint                 // 无符号整型
    Uint8                // 无符号 8 位整型
    Uint16               // 无符号 16 位整型
    Uint32               // 无符号 32 位整型
    Uint64               // 无符号 64 位整型
    Uintptr              // 指针
    Float32              // 单精度浮点数
    Float64              // 双精度浮点数
    Complex64            // 64 位复数类型
    Complex128           // 128 位复数类型
    Array                // 数组
    Chan                 // 通道
    Func                 // 函数
    Interface            // 接口
    Map                  // 映射
    Ptr                  // 指针
    Slice                // 切片
    String               // 字符串
    Struct               // 构造体
    UnsafePointer        // 底层指针
)

** 办法 3: 应用.(type)

func showType(typeOfUnknown interface{}) {switch t := typeOfUnknown.(type) {
    case string:
        fmt.Printf("string: %v\n", t)
    case int:
        fmt.Printf("int: %v\n", t)
    case BaseService:
        fmt.Printf("%v\n", t)
    case MyEnum:
        fmt.Printf("MyEnum:%v\n", t)
    }
}

unknowValue = baseService
showType(unknowValue)

unknowValue = CAT
showType(unknowValue)

unknowValue = "123"
showType(unknowValue)

输入后果

{<nil> BaseService 5}
MyEnum:0
string: 123