Golang语言学习拿捏Go反射示例教程

var a int

type FanOne struct {
	name string
}
func main(){	
	var a int = 1
	var d FanOne
	fmt.Println(reflect.TypeOf(a))  		  // int 
	// 这里就拿到了a的类型！注意是类型！不是类别！虽然这个类型和类别是一样的
	// 后面会说说类型(Type)和类别(Kind)的区别
	fmt.Println(reflect.ValueOf(a).Kind())    //int 
	//这样就拿到了a的类别，是通过a的值来判断类别
	fmt.Println(reflect.TypeOf(d))			  //main.FanOne
	//类型是main.FanOne  是在main里面定义的FanOne
	fmt.Println(reflect.ValueOf(d).Kind())    //struct
	//类别是struct
	// 输出 d 的类型名称和种类，类型名称就是 FanOne
	//而 FanOne 属于一种结构体类别，因此类别为 struct
}

reflect.TypeOf()			 //获取变量的类型，返回reflect.Type类型
reflect.ValueOf()			 //获取变量的值，返回reflect.Value类型
reflect.Value.Kind()		 //获取变量的类别，返回一个常量
reflect.Value.Interface()	 //转换成interface{}类型

reflect.ValueOf(xxx).Elem()

func CreatePrimitiveObjects(t reflect.Type) reflect.Value {
    return reflect.Zero(t)
}

reflect.New()

package main

import (
	"fmt"
	"reflect"
)

func FanOne() string {
	return "一键三连"
}

func FanOneWoW(a string) string {
	return fmt.Sprintf("%s要给FanOne一键三连噢~",a)
}

func main() {
	FanOneNotArgs := reflect.ValueOf(FanOne).Call([]reflect.Value{})		 //无参数
	FanOneHaveArgs := reflect.ValueOf(FanOneWoW).Call([]reflect.Value{reflect.ValueOf("我")})  //有参数
	fmt.Println(FanOneNotArgs[0])
	fmt.Println(FanOneHaveArgs[0])
}

func fn(callback interface{}, bytes []byte) {
		//coding
}
type aaa struct {
	Name string `json:"name"`
	Age  int    `json:"age"`
}
func Test(t *testing.T) {
		fn(func(a []*aaa) string {
		aaas := a
		for i, item := range aaas {
			fmt.Println(i, item)
		}
		fmt.Println("12312312, ", aaas)
		return "xxxx"
	}, []byte("[{\"name\":\"111\",\"age\":1}, {\"name\":\"gsjk\",\"age\":2}]"))

	fn(func(a []aaa) string {
		aaas := a
		for i, item := range aaas {
			fmt.Println(i, item)
		}

		fmt.Println("12312312, ", aaas[0])
		return "xxxx"
	}, []byte("[{\"name\":\"111\",\"age\":1}, {\"name\":\"gsjk\",\"age\":2}]"))

	fn(func(a *aaa) string {
		fmt.Println("12312312, ", a)
		aaas := a
		fmt.Println("12312312, ", aaas)
		return "xxxx"
	}, []byte("{\"name\":\"gsjk\",\"age\":2}"))

	fn(func(a string) string {
		fmt.Println("12312312, ", a)
		aaas := a
		fmt.Println("12312312, ", aaas)
		return "xxxx"
	}, []byte("\"sss\""))

	fn(func(a int) string {
		fmt.Println("-----------, ", a)
		aaas := a
		fmt.Println("-----------, ", aaas)
		return "xxxx"
	}, []byte("123"))
}

go test xxx_test.go
go test -v xxx_test.go

func(a []*aaa) string {
		aaas := a
		for i, item := range aaas {
			fmt.Println(i, item)
		}
		fmt.Println("12312312, ", aaas)
		return "xxxx"
	}, []byte("[{\"name\":\"111\",\"age\":1}, {\"name\":\"gsjk\",\"age\":2}]"))

func fn(callback interface{}, bytes []byte) {
	v := reflect.ValueOf(callback)  //0xbaff40
	t := reflect.TypeOf(callback)  //func([]*main.aaa) string
}

paramsValue := t.In(0)  //[]*main.aaa

	val := reflect.New(paramsValue)
	newT := val.Interface()
	fmt.Printf("valValue:%v , valType: %T \n",val,val)    //valValue:&[] , valType: reflect.Value
	fmt.Printf("newTValue:%v , newTType: %T \n",newT,newT)//newTValue:&[] , newTType: *[]*main.aaa

	if v.IsValid() {                       			//function valid or not
		_ = json.Unmarshal(bytes, newT)               //byte to json
	}

	fmt.Printf("调用 callback 结束 callback ret = %s \n", v.Call([]reflect.Value{reflect.ValueOf(newT)}))
	fmt.Printf("*************************\n")

package main

import (
  "fmt"
  "reflect"
)

func main(){
  var a int = 1
  var b *int = &a
  var c **int = &b
  fmt.Println(a, *b, c)
  fmt.Println(reflect.TypeOf(a))
  fmt.Println(reflect.TypeOf(*b))
  fmt.Println(reflect.TypeOf(b))
}

	fmt.Printf("调用 callback 结束 callback ret = %s \n", v.Call([]reflect.Value{reflect.ValueOf(newT).Elem()}))
	fmt.Printf("*************************\n")