ingerface{}类型转换总结

Posted 2021-09-04 麦穗儿

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