Go语言之类型断言与反射

作者: CaiGuangyin | 来源:发表于2020-04-27 15:54 被阅读0次

Go语言之类型断言与反射
Go语言类型转换和类型断言
Go语言类型断言简述
go语言的类型断言
第04天(面对对象编程)_04
go语言中的类型断言与类型转换
Go语言类型转换，类型断言，类型开关
GO语言之类型断言
17.Go语言·类型断言
初识Go语言-1

小记
    make与new的区别
    map操作
类型断言
反射
    1. 变量的内在机制
    2. 反射与空接口
    3. 怎么分析？
    4. 常用类型的变量类型分析
    5. 通过反射获取结构体的字段值信息和类型信息
    6. 通过反射给结构体字段赋值
    7. 获取结构体方法的类型信息
    8. 通过反射调用结构体的方法
    9. 通过反射获取结构体字段的tag信息

小记

make与new的区别

make()用来分配引用类型的内存，比如map、slice以及channel
new()用来分配除了引用类型以外的所有其他类型的内存，比如int、数组等； new返回类型的指针；

package main

import `fmt`

func main() {
    var a *int = new(int)
    fmt.Println(a) // a是一个int指针类型 0xc00000a0c8
    // a = 100      // 此时不能用a直接赋值，因为a是int指针类型，而100是int类型，两者类型不同，所以不同赋值
    *a = 100 // 必须要在a前面加一个星号*，*a 表示内存地址指向的那块内存空间，*a=100表示将数字100存储到a(内存地址)指向的那块内存空间中；
    fmt.Println(*a)

    var b *[]int = new([]int)
    // (*b)[0] = 1      // 此时b是一个指针类型，它的值是一个内存地址
    fmt.Println(b, &b)       // b的值是一个内存地址，而这个内存地址也需要一块内存空间去存储，所以 &b是取b的内存地址
    fmt.Printf("%p\n", b)    // 打印：0xc0000044c0, 这是b的值
    fmt.Println(*b)          // 是一个空切片，打印：[]
    *b = make([]int, 5, 100) // 给b(内存地址)分配一块内存空间并初始化切片长度为5，容量为100，这里才可以进行索引操作，如下
    (*b)[0] = 10
    (*b)[1] = 20
    (*b)[2] = 30
    fmt.Println(*b) // 打印：[10 20 30 0 0]

    var c = make([]int, 5, 20)
    c[0] = 100
    c[1] = 200
    fmt.Println(c) // 打印：[100 200 0 0 0]
    // 通过上面的例子可以看出，用new()初始化引用类型的变量是多余的
}

map操作

package main

import `fmt`

func main() {
    var m map[string]int  // map声明后未初化是nil
    fmt.Println(m == nil) // true

    // 初始化 方式一：
    m = map[string]int{}
    // 对未初始化的map直接赋值会抛出异常 panic: assignment to entry in nil map
    m["cai"] = 22000
    m["kung"] = 20000
    fmt.Println(m, len(m))

    // 初始化 方式二：
    n := make(map[string]int)
    n["guang"] = 12000
    n["wang"] = 10000
    n["guo"] = 8000
    n["liang"] = 9000
    fmt.Println(n, len(n))

    value, ok := n["wangg"]
    if ok {
        fmt.Println("value:", value)
    } else {
        fmt.Println("value is not exists.")
    }
}

类型断言

空接口与类型断言
空接口类型的变量可以存入任何类型的值

package main

import (
    `fmt`
)

func main() {
    var a = 10
    // testInterface(a)

    var b = "hello world"
    // testInterface(b)

    var c = 3.1415926
    
    // 构造一个万能类型的数组list，什么都有存
    var list []interface{}
    list = append(list, a, b, c)

    findType(list)
}

func testInterface(a interface{})  {
    b, ok := a.(int)
    if ok {
        fmt.Printf("a is int: %d, type: %T\n", b, b) // a is int: 10, type: int
    }

    c, ok := a.(string)
    if ok {
        fmt.Printf("a is string: %s, type: %T\n", c, c)  // a is string: hello world, type: string
    }
}

func findType(a interface{})  {
    list, ok := a.([]interface{})
    if ok {
        for _, value := range list {
            switch v := value.(type) {
            case int:
                fmt.Printf("value: %d, type: %T\n", v, v)
            case string:
                fmt.Printf("value: %s, type: %T\n", v, v)
            case float64:
                fmt.Printf("value: %f, type: %T\n", v, v)
            case []interface{}:
                fmt.Println("type: []interface{}")
            default:
                fmt.Println("unknown type.")
            }
        }
    } else {
        fmt.Println("a is not []interface{} type.")
    }

}

b, ok := a.(int) 断言a为int类型，如果断言错误则ok为false，断言正确，ok为true且将值赋值给b；

value.(type) type是关键字，这种用法只能在 switch语句中使用；可以这样直接赋值v := value.(type)，在case中就可以直接使用v了，避免多次类型断言；

反射

1. 变量的内在机制

参考文档： Golang反射

类型信息，这部分是元信息，是预先定义好的；
值信息，这部分是程序运行过程中，动态改变的；

2. 反射与空接口

A. 空接口可以存储任何类型的变量；
B.那么给你一个空接口，怎么知道里面存储的是什么类型的变量？
C. 在运行时动态的获取一个变量的类型信息和值信息，就叫反射；

3. 怎么分析？

A.内置包 reflect;
B. 获取类型信息： reflect.TypeOf
C. 获取值信息： reflect.ValueOf

获取一个空接口的变量类型

package main

import (
    `fmt`
    `reflect`
)

func reflectExample(a interface{})  {
    t := reflect.TypeOf(a)
    fmt.Println("a的类型是：", t)  // 打印：a的类型是： float64
}

func main() {
    var x float64 = 3.1415926
    reflectExample(x)
}

4. 常用类型的变量类型分析

reflect.ValueOf(a).Type() 和 reflect.TypeOf(a)功能相同

package main

import (
    `fmt`
    `reflect`
)

func reflectType(a interface{})  {
    t := reflect.TypeOf(a)
    k := t.Kind()
    fmt.Println("a的类型是：", t.String(), k.String())  // 打印：a的类型是： float64
}

func reflectValue(a interface{})  {
    v := reflect.ValueOf(a)
    t := v.Type()            //  reflect.ValueOf(a).Type() 和 reflect.TypeOf(a) 功能相同
    // k := v.Kind()

    t1 := reflect.TypeOf(a)
    t1.Kind()

    fmt.Println("a的类型是：", t.String())

    switch t.Kind() {
    case reflect.Int:
        fmt.Println("a is a int. ")
    case reflect.Float32, reflect.Float64:
        fmt.Println("a is a Float.")
    case reflect.String:
        fmt.Println("a is a String.")
    default:
        fmt.Println("other type.")
    }
}


func main() {
    var x = 3.1415926
    reflectType(x)
    reflectValue(x)
}

5. 通过反射获取结构体的字段值信息和类型信息

package main

import (
    `fmt`
    `reflect`
)

type Student struct {
    Name string
    Age  int
    Sex  string
}

func main() {
    var stu = Student{
        Name: "caigy",
        Age:  18,
        Sex:  "male",
    }

    // 类型信息是静态的，在编译时就确定了；
    // 值信息是动态的，在运行时才能确定
    v := reflect.ValueOf(stu)
    t := v.Type()
    fmt.Println("stu的类型：", t.Kind().String())   // 变量类型为struct

    switch t.Kind() {
    case reflect.String:
        fmt.Println("is string.")
    case reflect.Struct:
        fmt.Println("is struct.")
        fmt.Println("结构体字段个数：", v.NumField()) // t.NumField()获取结构体字段数量，输出3

        for i := 0; i < v.NumField(); i++ {
            fmt.Println("type: ", t.Field(i),t.Field(i).Type) // t.Field(i) 通过下标获取字段的类型信息,
            fmt.Println("value: ", v.Field(i), v.Field(i).Type())  // v.Field(i) 通过下标获取字段的值信息,
        }
        fmt.Println("name: ", v.FieldByName("Name"))  // v.FieldByName("Name")根据字段名称获取字段的值
        fmt.Printf("struct value: %+v, type: %T\n", v.Interface(), v.Interface())  // {Name:caigy Age:18 Sex:male}, type: main.Student
        name := v.FieldByName("Name").Interface()
        fmt.Printf("name: %T, %+v\n", name, name)  // name: string, caigy
    }
}

v.Type() 返回变量stu的类型信息；

v.Kind() 返回变量stu的类型，为struct；

v.Field(i) 通过下标获取一个字段的值信息，返回的类型是reflect.Value；

v.Field(i).Type()返回字段的值类型；

v.FieldByName("Name") 通过字段名称获取字段的值信息；

v.FieldByName("Name").Interface()获取指定字段的值，如Name，获取到的值为caigy，值类型为string；

v.Interface() 返回结构所有字段;

t.Field(i)通过下标获取字段的类型信息，返回的类型是reflect.StructField;

t.Field(i).Type 返回结构体字段类型对象，通过t.Field(i).Type.Kind()获取字段具体类型；

6. 通过反射给结构体字段赋值

注意：通过反射给结构体字段赋值，reflect.ValueOf(&stu) 必须传入指针类型&stu；

package main

import (
    `fmt`
    `reflect`
)

type Student struct {
    Name string
    Age  int
    Sex  string
}

func main() {
    var stu Student
    v := reflect.ValueOf(&stu)
    v.Elem().FieldByName("Name").SetString("caigy")
    v.Elem().FieldByName("Age").SetInt(18)
    v.Elem().FieldByName("Sex").SetString("male")

    fmt.Printf("Student: %+v", stu)  // Student: {Name:caigy Age:18 Sex:male}
}

v.Elem() 返回指针v指向的值(内存)，所以要想给结构体字段赋值必需这样使用：v.Elem().FieldByName("Name").SetString("caigy")

7. 获取结构体方法的类型信息

方法的类型信息是静态信息，编译时已经确定好了，所以应该用reflect.TypeOf(&stu)或者reflect.ValueOf(&stu).Type() 获取得方法的类型信息

package main

import (
    `fmt`
    `reflect`
)

type Student struct {
    Name string
    Age  int
    Sex  string
}

func (stu *Student) SetName(name string) {
    stu.Name = name
}

func (stu *Student) PrintVal() {
    fmt.Println(stu.Name, stu.Age, stu.Sex)
}

func (stu *Student) InitVal() {
    stu.Name = "CaiGY"
    stu.Age = 18
    stu.Sex = "Male"
}

func main() {
    var stu Student
    v := reflect.ValueOf(&stu)
    t := v.Type()

    fmt.Println(t.NumMethod()) // 返回Student的方法个数
    for i := 0; i < t.NumMethod(); i++ {
        method := t.Method(i)
        fmt.Printf("num: %d, methodName: %+v, methodSign: %+v\n", i, method.Name, method.Type)
        // 打印结果如下：
        // num: 0, methodName: InitVal, methodSign: func(*main.Student)
        // num: 1, methodName: PrintVal, methodSign: func(*main.Student)
        // num: 2, methodName: SetName, methodSign: func(*main.Student, string)
    }

    printVal, ok := t.MethodByName("PrintVal")
    // initVal, ok := t.MethodByName("InitVal")
    if !ok {
        fmt.Println("not ok.")
        return
    }
    fmt.Println("printVal.Type: ", printVal.Type)       // 返回方法类型：func(*main.Student)
}

t.NumMethod() 返回方法的个数；

t.Method(i) 通过下标获取一个方法对象(reflect.Method)，

printVal, ok := t.MethodByName("PrintVal") 通过名称获取方法对象(reflect.Method);

t.Method(i).Name 返回访求的名称；

t.Method(i).Type 返回访求的签名，如SetName()方法的签名：func(*main.Student, string);

8. 通过反射调用结构体的方法

调用结构体的方法，是运行时确定的，所以要通过值类型来获取调用： reflect.ValueOf(&stu)；

package main

import (
    `fmt`
    `reflect`
)

type Student struct {
    Name string
    Age  int
    Sex  string
}

func (stu *Student) SetName(name string) {
    stu.Name = name
}

func (stu *Student) PrintVal() {
    fmt.Println(stu.Name, stu.Age, stu.Sex)
}

func (stu *Student) InitVal() {
    stu.Name = "CaiGY"
    stu.Age = 18
    stu.Sex = "Male"
}

func main() {
    var stu Student
    v := reflect.ValueOf(&stu)

    printVal := v.MethodByName("PrintVal")
    initVal := v.MethodByName("InitVal")

    // 无参方法的调用
    var arg []reflect.Value
    initVal.Call(arg)   // 需要传入一个空数组：[]reflect.Value
    printVal.Call(arg)  // CaiGY 18 Male

    // 有参方法的调用：
    setName := v.MethodByName("SetName")
    // 1. 先构造方法的参数
    var args []reflect.Value
    name := reflect.ValueOf("CaiGuangyin")
    args = append(args, name)
    // 2. 通过Call()传入第1步构造的参数来调用SetName方法
    setName.Call(args)

    fmt.Printf("student: %+v\n", stu)   // student: {Name:CaiGuangyin Age:18 Sex:Male}
}

9. 通过反射获取结构体字段的tag信息

tag属于静态信息，保存在字段的类型信息里面，所以要用 reflect.ValueOf(stu).Type()或者reflect.TypeOf(stu)来取得变量的类型信息

package main

import (
    `fmt`
    `reflect`
)

type Student struct {
    Name string `json:"name" db:"meicai"`
    Age int `json:"age" db:"hehe"`
}

func main() {
    var stu Student
    v := reflect.ValueOf(stu)
    t := v.Type()

    for i := 0; i < t.NumField(); i++ {
        field := t.Field(i)
        tag := field.Tag
        fmt.Println("json: ", tag.Get("json"))      // 获取tag名为json的值
        fmt.Println("db: ", tag.Get("db"))      // 获取tag名为db的值
    }

    // 通过 tag.Get(key)获取tag的值，如果key不存在时，则默认返回空字符串
    // 通过 tag.Lookup(key)获取tag的值时会返回值本身和一个bool值，可通过bool值来判断key是否存在
    name, ok := t.FieldByName("Name")
    if !ok {
        fmt.Println("field name is not exists.")
        return
    }
    jsonVal, ok := name.Tag.Lookup("json")
    if ! ok {
        fmt.Println("tag json is not exists.")
        return
    }
    fmt.Println("json tag value: ", jsonVal)    //json tag value:  name
}