Go语言之反射入门

Go反射

通过反射获取num变量的值

package main

import (
	"fmt"
	"reflect"
)

func main() {
	var num int = 6
	reflectTest01(num)
}
func reflectTest01(b interface{}){
	rType := reflect.TypeOf(b)
	fmt.Printf("rType= %v,类型是%T\n",rType,rType)

	rValue := reflect.ValueOf(b)
	fmt.Printf("rValue= %v,类型是%T\n",rValue,rValue)

	v := rValue.Int() // Value->Int
	n1 := 6
	sum := v+int64(n1)
	fmt.Println("sum=",sum)

	rInterface := rValue.Interface() // 先转为空接口
	res := rInterface.(int) // 类型断言的最佳实践，再将空接口断言为int类型
	fmt.Printf("res=%v,类型为%T",res,res)
}

通过反射获取结构体中的某个值

package main

import (
	"fmt"
	"reflect"
)

func main() {
	stu := Stu{"lwt",21}
reflectTest02(stu)
}

func reflectTest02(b interface{}){
	rType := reflect.TypeOf(b)
	fmt.Println(rType)

	rVal := reflect.ValueOf(b)
	fmt.Println(rVal)

	// 获取变量对应的Kind
	rKind := rVal.Kind()
	fmt.Println(rKind)

	rInterface := rVal.Interface()
	fmt.Println(rInterface)
	switch  {

	}
	stu,ok:=rInterface.(Stu)
	if ok {
		fmt.Printf("stu.Name= %v",stu.Name)
	}
}

type Stu struct {
	Name string
	Age int
}

type Monster struct {
	Name string
	Age int
}

通过反射获取结构体的字段方法

package main

import (
	"fmt"
	"reflect"
)

type Monster struct {
	Name string `json:"Name"`
	Age  int    `json:"monster_Age"`
	Sex  string
}

func (m Monster) Print() {
	fmt.Println("----start----")
	fmt.Println(m)
	fmt.Println("----end----")
}
func (m Monster) GetSum(n1, n2 int) int { // 0
	return n1 + n2
}

/*
接受四个值，给Monster赋值
*/
func (m Monster) Set(name string, age int, sex string) { // 1
	m.Name = name
	m.Age = age
	m.Sex = sex
}

func TestStruct(a interface{}) { // 2
	rType := reflect.TypeOf(a)
	rValue := reflect.ValueOf(a)
	rKind := rValue.Kind()
	if rKind != reflect.Struct { // 类别判断
		fmt.Println("结束")
		return
	}

	num := rValue.NumField()
	fmt.Printf("结构体的字段有%d个\n", num)
	for i := 0; i < num; i++ {
		fmt.Printf("结构体字段分别为%d-%v  ", i, rValue.Field(i))
		// 获取struct标签需要通过reflect.Type来获取tag标签的值
		tagVal := rType.Field(i).Tag.Get("json")
		if tagVal != "" {
			fmt.Printf("字段 %d的标签是 %v\n", i, tagVal)
		}
	}

	numOfMethod := rValue.NumMethod()
	fmt.Printf("结构体的方法有%d个", numOfMethod)
	fmt.Println()
	// 获取到第二个方法并调用，但调用的却是第一个方法？
	// 按ascii字母排序0123
	rValue.Method(1).Call(nil)

	var paramsSlice []reflect.Value // 声明了这个切片
	paramsSlice = append(paramsSlice,reflect.ValueOf(10))
	paramsSlice = append(paramsSlice,reflect.ValueOf(50))
	resSlice := rValue.Method(0).Call(paramsSlice) // 传入切片，返回仍是切片
	fmt.Println("resSlice=",resSlice)
	fmt.Println("resSlice=",resSlice[0].Int()) // 60为Int，如果不知道类型，用类型断言


}
func main() {
	monster := Monster{"lwt", 22, "男"}
	TestStruct(monster)
}