Golang反射获取变量类型和值的方法详解

func main() {
    type MyInt32 int32
    a := MyInt32(1)
    b := int32(1)
    fmt.Printf("reflect.TypeOf(a):%v Kind:%v\n", reflect.TypeOf(a), reflect.TypeOf(a).Kind())
    fmt.Printf("reflect.TypeOf(b):%v Kind:%v\n", reflect.TypeOf(b), reflect.TypeOf(b).Kind())
}

// A Kind represents the specific kind of type that a Type represents.
// The zero Kind is not a valid kind.
type Kind uint
const (
	Invalid Kind = iota
	Bool
	Int
	Int8
	Int16
	Int32
	Int64
	Uint
	Uint8
	Uint16
	Uint32
	Uint64
	Uintptr
	Float32
	Float64
	Complex64
	Complex128
	Array
	Chan
	Func
	Interface
	Map
	Pointer
	Slice
	String
	Struct
	UnsafePointer
)

func main() {
    type myStruct struct {
    }
    a := &myStruct{}
    typeA := reflect.TypeOf(a)
    fmt.Printf("TypeOf(a):%v Kind:%v\n", typeA, typeA.Kind())
    fmt.Printf("TypeOf(a).Elem():%v Elem().Kind:%v\n", typeA.Elem(), typeA.Elem().Kind())
    s := []int64{}
    typeS := reflect.TypeOf(s)
    fmt.Printf("TypeOf(s):%v Kind:%v\n", typeS, typeS.Kind())
    fmt.Printf("TypeOf(s).Elem():%v Elem().Kind:%v\n", typeS.Elem(), typeS.Elem().Kind())
}

func main() {
    type secStruct struct {
        Cnt []int64
    }
    type myStruct struct {
        Num   int    `json:"num_json" orm:"column:num_orm"`
        Desc  string `json:"desc_json" orm:"column:desc_orm"`
        Child secStruct
    }
    s := myStruct{}
    typeS := reflect.TypeOf(s)
    // 成员数量
    fmt.Printf("NumField:%v \n", typeS.NumField())
    // 每个成员的信息 包括名称、类型、Tag
    for i := 0; i < typeS.NumField(); i++ {
        // 通过下标访问成员
        fmt.Printf("Field(%v):%+v\n", i, typeS.Field(i))
    }
    // 通过名称访问成员
    field, ok := typeS.FieldByName("Num")
    fmt.Printf("FieldByName(\"Num\") ok:%v field:%+v\n", ok, field)
    // 获取tag值
    fmt.Printf("json tag val:%+v\n", field.Tag.Get("json"))
    // 获取嵌套结构体的字段
    fmt.Printf("Cnt field:%+v\n", typeS.FieldByIndex([]int{2, 0}))
}

func main() {
    b := int32(1)
    valueB := reflect.ValueOf(b)
    fmt.Printf("reflect.TypeOf(b):%v Kind:%v\n", valueB, valueB.Kind())
    s := "abcdefg"
    valueS := reflect.ValueOf(s)
    fmt.Printf("reflect.TypeOf(s):%v Kind:%v Len:%v\n", valueS, valueS.Kind(), valueS.Len())
}

func main() {
    type secStruct struct {
        Cnt []int64
    }
    type myStruct struct {
        Num   int    `json:"num_json" orm:"column:num_orm"`
        Desc  string `json:"desc_json" orm:"column:desc_orm"`
        Child secStruct
    }
    s := myStruct{
        Num:   100,
        Desc:  "desc",
        Child: secStruct{[]int64{1, 2, 3}},
    }
    valueS := reflect.ValueOf(s)
    // 成员数量
    fmt.Printf("NumField:%v \n", valueS.NumField())
    // 每个成员的值
    for i := 0; i < valueS.NumField(); i++ {
        // 通过下标访问成员
        fmt.Printf("value(%v):%+v\n", i, valueS.Field(i))
    }
    // 通过名称访问成员
    value := valueS.FieldByName("Num")
    fmt.Printf("FieldByName(\"Num\") value:%v\n", value)
    // 获取嵌套结构体的字段
    fmt.Printf("Cnt field:%+v\n", valueS.FieldByIndex([]int{2, 0}))
}

func main() {
    s := []int64{1, 2, 3, 4, 5, 6}
    valueS := reflect.ValueOf(s)
    fmt.Printf("ValueOf(s):%v Kind:%v Len:%v\n", valueS, valueS.Kind(), valueS.Len())
    for i := 0; i < valueS.Len(); i++ {
        fmt.Printf("valueS.Index(%v):%v\n", i, valueS.Index(i))
    }
}

func main() {
    m := map[int]string{
        1: "1",
        2: "2",
        3: "3",
    }
    valueM := reflect.ValueOf(m)
    // 迭代器访问
    iter := valueM.MapRange()
    for iter.Next() {
        fmt.Printf("key:%v val:%v\n", iter.Key(), iter.Value())
    }
    fmt.Println("------")
    // 通过key访问
    keys := valueM.MapKeys()
    for i := 0; i < len(keys); i++ {
        fmt.Printf("key:%v val:%v\n", keys[i], valueM.MapIndex(keys[i]))
    }
}

func main() {
    a := int32(10)
    valueA := reflect.ValueOf(a)
    fmt.Printf("ValueOf(a):%v\n", valueA)
    fmt.Printf("Interface():%v\n", valueA.Interface())
    ai, ok := valueA.Interface().(int32)
    fmt.Printf("ok:%v val:%v\n", ok, ai)
}

func main() {
    a := int32(10)
    valueA := reflect.ValueOf(a)
    fmt.Printf("valueA :%v\n", valueA.CanSet())
    b := int32(100)
    valuePtrB := reflect.ValueOf(&b)
    fmt.Printf("valuePtrB:%v Elem:%v\n", valuePtrB.CanSet(), valuePtrB.Elem().CanSet())
    valuePtrB.Elem().Set(reflect.ValueOf(int32(200)))
    fmt.Printf("b:%v Elem:%v\n", b, valuePtrB.Elem())
}