Go语言通过反射实现获取各种类型变量的值

package main
import (
	"fmt"
	"reflect"
)
func main() {
	type MyInt32 int32
	a := MyInt32(1)
	b := int32(1)
	// reflect.TypeOf(a):main.MyInt32 Kind:int32
	fmt.Printf("reflect.TypeOf(a):%v Kind:%v\n", reflect.TypeOf(a), reflect.TypeOf(a).Kind())
	// reflect.TypeOf(b):int32 Kind:int32
	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
)

// Elem returns a type's element type.
// It panics if the type's Kind is not Array, Chan, Map, Pointer, or Slice.
Elem() Type

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

package main
import (
	"fmt"
	"reflect"
)
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
}
func main() {
	s := myStruct{}
	typeS := reflect.TypeOf(s)
	// 成员数量
	// NumField:3
	fmt.Printf("NumField:%v \n", typeS.NumField())
	// 每个成员的信息 包括名称、类型、Tag
	for i := 0; i < typeS.NumField(); i++ {
		// 通过下标访问成员
		// Field(0):{Name:Num PkgPath: Type:int Tag:json:"num_json" orm:"column:num_orm" Offset:0 Index:[0] Anonymous:false}
		// Field(1):{Name:Desc PkgPath: Type:string Tag:json:"desc_json" orm:"column:desc_orm" Offset:8 Index:[1] Anonymous:false}
		// Field(2):{Name:Child PkgPath: Type:main.secStruct Tag: Offset:24 Index:[2] Anonymous:false}
		fmt.Printf("Field(%v):%+v\n", i, typeS.Field(i))
	}
	// 通过名称访问成员
	field, ok := typeS.FieldByName("Num")
	// FieldByName("Num") ok:true field:{Name:Num PkgPath: Type:int Tag:json:"num_json" orm:"column:num_orm" Offset:0 Index:[0] Anonymous:false}
	fmt.Printf("FieldByName(\"Num\") ok:%v field:%+v\n", ok, field)
	// 获取tag值
	// json tag val:num_json
	fmt.Printf("json tag val:%+v\n", field.Tag.Get("json"))
	if value, ok := field.Tag.Lookup("orm"); ok {
		// rm tag val:column:num_orm
		fmt.Printf("orm tag val:%+v\n", value)
	}
	// 获取嵌套结构体的字段
	// Cnt field:{Name:Child PkgPath: Type:main.secStruct Tag: Offset:24 Index:[2] Anonymous:false}
	fmt.Printf("Cnt field:%+v\n", typeS.FieldByIndex([]int{2}))
	// Cnt field:{Name:Cnt PkgPath: Type:[]int64 Tag: Offset:0 Index:[0] Anonymous:false}
	fmt.Printf("Cnt field:%+v\n", typeS.FieldByIndex([]int{2, 0}))
}

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

package main
import (
	"fmt"
	"reflect"
)
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
}
func main() {
	s := myStruct{
		Num:   100,
		Desc:  "desc",
		Child: secStruct{[]int64{1, 2, 3}},
	}
	valueS := reflect.ValueOf(s)
	// 成员数量
	// NumField:3
	fmt.Printf("NumField:%v \n", valueS.NumField())
	// 每个成员的值
	for i := 0; i < valueS.NumField(); i++ {
		// 通过下标访问成员
		// value(0):100
		// value(1):desc
		// value(2):{Cnt:[1 2 3]}
		fmt.Printf("value(%v):%+v\n", i, valueS.Field(i))
	}
	// 通过名称访问成员
	value := valueS.FieldByName("Num")
	// FieldByName("Num") value:100
	fmt.Printf("FieldByName(\"Num\") value:%v\n", value)
	// 获取嵌套结构体的字段
	// Cnt field:[1 2 3]
	fmt.Printf("Cnt field:%+v\n", valueS.FieldByIndex([]int{2, 0}))
}

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

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

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

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