go语言反射

go语言反射

反射的类型对象（reflect.Type）

支持反射的语言可以在程序编译期将变量的反射信息，如字段名称、类型信息、结构体信息等整合到可执行文件中，并给程序提供接口访问反射信息，这样就可以在程序运行期获取类型的反射信息，并且有能力修改它们。

Go程序在运行期使用reflect包访问程序的反射信息。

在上一篇博客中我们介绍了空接口。 空接口可以存储任意类型的变量，那我们如何知道这个空接口保存的数据是什么呢？ 反射就是在运行时动态的获取一个变量的类型信息和值信息。

reflect包

在Go语言的反射机制中，任何接口值都由是一个具体类型和具体类型的值两部分组成的(我们在上一篇接口的博客中有介绍相关概念)。 在Go语言中反射的相关功能由内置的reflect包提供，任意接口值在反射中都可以理解为由reflect.Type和reflect.Value两部分组成，并且reflect包提供了reflect.TypeOf和reflect.ValueOf两个函数来获取任意对象的Value和Type。

反射的类型（Type）与种类（Kind）

在使用反射时，需要首先理解类型（Type）和种类（Kind）的区别。编程中，使用最多的是类型，但在反射中，当需要区分一个大品种的类型时，就会用到种类（Kind）。例如，需要统一判断类型中的指针时，使用种类（Kind）信息就较为方便，区分哪一个名称时候就需要用到(Name)

reflect.ValueOf()返回的是reflect.Value类型，其中包含了原始值的值信息。reflect.Value与原始值之间可以互相转换。

reflect.Value类型提供的获取原始值的方法如下：

方法	说明
Interface() interface {}	将值以 interface{} 类型返回，可以通过类型断言转换为指定类型
Int() int64	将值以 int 类型返回，所有有符号整型均可以此方式返回
Uint() uint64	将值以 uint 类型返回，所有无符号整型均可以此方式返回
Float() float64	将值以双精度（float64）类型返回，所有浮点数（float32、float64）均可以此方式返回
Bool() bool	将值以 bool 类型返回
Bytes() []bytes	将值以字节数组 []bytes 类型返回
String() string	将值以字符串类型返回

如下go语言中的数据类型

const (
    Invalid Kind = iota  // 非法类型
    Bool                 // 布尔型
    Int                  // 有符号整型
    Int8                 // 有符号8位整型
    Int16                // 有符号16位整型
    Int32                // 有符号32位整型
    Int64                // 有符号64位整型
    Uint                 // 无符号整型
    Uint8                // 无符号8位整型
    Uint16               // 无符号16位整型
    Uint32               // 无符号32位整型
    Uint64               // 无符号64位整型
    Uintptr              // 指针
    Float32              // 单精度浮点数
    Float64              // 双精度浮点数
    Complex64            // 64位复数类型
    Complex128           // 128位复数类型
    Array                // 数组
    Chan                 // 通道
    Func                 // 函数
    Interface            // 接口
    Map                  // 映射
    Ptr                  // 指针
    Slice                // 切片
    String               // 字符串
    Struct               // 结构体
    UnsafePointer        // 底层指针
)

Go程序中的类型（Type）指的是系统原生数据类型，如int、string、bool、float32等类型，以及使用type关键字定义的类型，这些类型的名称就是其类型本身的名称。例如使用type x struct{}定义结构体时，x就是struct{}的类型。种类（Kind）指的是对象归属的品种

go语言中反射修改基本类型值，在go语言中可以通过指针修改值

reflect.ValueOf()返回的是reflect.Value类型，其中包含了原始值的值信息。reflect.Value与原始值之间可以互相转换。

reflect.Value类型提供的获取原始值的方法如下：

方法	说明
Interface() interface {}	将值以 interface{} 类型返回，可以通过类型断言转换为指定类型
Int() int64	将值以 int 类型返回，所有有符号整型均可以此方式返回
Uint() uint64	将值以 uint 类型返回，所有无符号整型均可以此方式返回
Float() float64	将值以双精度（float64）类型返回，所有浮点数（float32、float64）均可以此方式返回
Bool() bool	将值以 bool 类型返回
Bytes() []bytes	将值以字节数组 []bytes 类型返回
String() string	将值以字符串类型返回

基本类型

示例如下

package main

import (
	"fmt"
	"reflect"
)

func main() {

	var i int = 8
	reflectType(i)
	var array  = []int {1,2,3}
	reflectType(array)
	reflectType(map[string]int{})
	reflectType("字符串")

	var cat = Cat{
		name:"小花",
		age : 1,
	}

	reflectType(cat)

	reflectType(true)

	var person = Person{
		name:"小明",
		age : 18,
	}

	reflectType(person)

	//指针没有 name()
	reflectType(&person)


}


//反射类型
func reflectType(x interface{})  {
	//拿到x类型信息
	T := reflect.TypeOf(x)

	fmt.Printf("类型type : %v \n ",T)
	//引用类型 name() 没有值
	fmt.Printf("name  : %s   , kind : %s   \n",T.Name(),T.Kind())
	//fmt.Printf("%T \n ",T)  //用的就是反射 打印类型



	// -----------  反射获取值类型 以及 值类型转换 ----
	var a int32 = 8
	reflectValue(a)

	var b int64 = 8
	reflectValue(b)

	var c int = 8
	reflectValue(c)

	var d bool = false
	reflectValue(d)



	// 反射修改值
	var m int  =  11;
	//由于go中函数传参是指拷贝，所以修改时候一般传地址
	reflectSetValue(&m)
	fmt.Printf("修改之后的值： %d \n " , m)


}


//反射修改基本类型值
func reflectSetValue( x interface{})  {
	//
	v := reflect.ValueOf(x)
	kind := v.Kind()  // 拿到值对应的种类

	//如果是指针类型
	if kind  == reflect.Ptr{

		//拿到值  传进来的是指针 必须先拿到指针 再拿值
		fmt.Printf("  转为int   %d  \n", v.Elem().Int())
		//反射修改值
		// .Elem() 取到指针再去修改值
		v.Elem().SetInt( 1233)

	}

}

//获取接口值信息
func reflectValue(x interface{})  {
	//拿到接口值信息
	v := reflect.ValueOf(x)
	kind := v.Kind()  // 拿到值对应的种类

	switch kind {
	case reflect.Int64:
		i := v.Int() //反射中获取原来类型的值信息
		fmt.Printf("当前值类型是：%s , 值是 %d \n ",v,i)
		//自定义根据对应类型转
		fmt.Printf("  转为int64   %s  \n", int64(i))
		break
	case reflect.Int32:
		i := v.Int() //反射中获取原来类型的值信息
		fmt.Printf("当前值类型是：%s , 值是 %d \n ",v,i)
		//根据对应类型转
		fmt.Printf("  转为 int32   %s  \n", int32(i))
		break
	case reflect.Int8:
		i := v.Int() //反射中获取原来类型的值信息
		fmt.Printf("当前值类型是：%s , 值是 %d \n ",v,i)
		//根据对应类型转
		fmt.Printf("  转为 Int8   %s \n ", int8(i))
		break
	case reflect.String:
		i := v.Int() //反射中获取原来类型的值信息
		fmt.Printf("当前值类型是：%s , 值是 %d \n ",v,i)
		//根据对应类型转
		fmt.Printf("  转为String   %s \n", string(i))
		break
	case reflect.Bool:
		i := v.Bool() //反射中获取原来类型的值信息
		fmt.Printf("当前值类型是：%s , 值是 %b \n ",v,i)
		//根据对应类型转
		fmt.Printf("  转为String   %s \n",bool( i))
		break
	default:
		fmt.Printf("  默认返回   %s \n", v.String())
	}

}




type Cat struct {
	name string
	age int8
}

type Person struct {
	name string
	age int8
}

结构体

任意值通过reflect.TypeOf()获得反射对象信息后，如果它的类型是结构体，可以通过反射值对象（reflect.Type）的NumField()和Field()方法获得结构体成员的详细信息。

reflect.Type中与获取结构体成员相关的的方法如下表所示。

方法	说明
Field(i int) StructField	根据索引，返回索引对应的结构体字段的信息。
NumField() int	返回结构体成员字段数量。
FieldByName(name string) (StructField, bool)	根据给定字符串返回字符串对应的结构体字段的信息。
FieldByIndex(index []int) StructField	多层成员访问时，根据 []int 提供的每个结构体的字段索引，返回字段的信息。
FieldByNameFunc(match func(string) bool) (StructField,bool)	根据传入的匹配函数匹配需要的字段。
NumMethod() int	返回该类型的方法集中方法的数目
Method(int) Method	返回该类型方法集中的第i个方法
MethodByName(string)(Method, bool)	根据方法名返回该类型方法集中的方法

获取结构体信息

reflect.Type的Field()方法返回StructField结构，这个结构描述结构体的成员信息，通过这个信息可以获取成员与结构体的关系，如偏移、索引、是否为匿名字段、结构体标签（StructTag）等，而且还可以通过StructField的Type字段进一步获取结构体成员的类型信息。StructField的结构如下：

type` `StructField ``struct` `{``  ``Name string     ``// 字段名``  ``PkgPath string    ``// 字段路径``  ``Type   Type    ``// 字段反射类型对象``  ``Tag    StructTag ``// 字段的结构体标签``  ``Offset  uintptr  ``// 字段在结构体中的相对偏移``  ``Index   []int   ``// Type.FieldByIndex中的返回的索引值``  ``Anonymous bool    ``// 是否为匿名字段``}

字段说明如下。

• Name：为字段名称。
• PkgPath：字段在结构体中的路径。
• Type：字段本身的反射类型对象，类型为reflect.Type，可以进一步获取字段的类型信息。
• Tag：结构体标签，为结构体字段标签的额外信息，可以单独提取。
• Index：FieldByIndex中的索引顺序。
• Anonymous：表示该字段是否为匿名字段。

示例：

package main

import (
	"fmt"
	"reflect"
)


//获取结构体重的信息
func main() {

	// 声明一个结构体
	type cat struct {
		Name string

		// 带有结构体tag的字段  编写Tag时，必须严格遵守键值对的规则
		Type int `json:"type" aaa:"100"`  //结构体标签（Struct Tag）
	}

	// 创建cat的实例
	ins := cat{Name: "小花", Type: 1}

	// 获取结构体实例的反射类型对象
	typeOfCat := reflect.TypeOf(ins)

	// 遍历结构体所有成员
	for i := 0; i < typeOfCat.NumField(); i++ {

		// 获取每个成员的结构体字段类型
		fieldType := typeOfCat.Field(i)

		// 输出成员名和tag
		fmt.Printf("name: %v  tag: '%v'\n", fieldType.Name, fieldType.Tag)
	}

	// 通过字段名, 找到字段类型信息
	if catType, ok := typeOfCat.FieldByName("Type"); ok {

		// 从tag中取出需要的tag
		fmt.Println(catType.Tag.Get("json"), catType.Tag.Get("aaa"))
	}
}

需要注意的是 tag必须是键值对格式 tag键值对之间要有空格，key:value之间不能有空格

反射设置值

package main

import (
	"fmt"
	"reflect"
)


//获取结构体重的信息
func main() {

	// 声明一个结构体
	type cat struct {
		Name string

		// 带有结构体tag的字段  编写Tag时，必须严格遵守键值对的规则
		Type int `json:"type" aaa:"100"`  //结构体标签（Struct Tag）
	}

	// 创建cat的实例
	ins := cat{Name: "小花", Type: 1}

	// 获取结构体实例的反射类型对象
	typeOfCat := reflect.TypeOf(&ins)


	//反射设置值
	valOfCat := reflect.ValueOf(&ins)
	t := reflect.TypeOf(&ins)
	println(" ----- ")
	//字段数量
	println(valOfCat.Elem().NumField())
	//根据struct 获取 字段属性
	fmt.Println(t.Elem().Field(1).Name)
	fmt.Println(t.Elem().Field(1).Type)
	fmt.Println(t.Elem().Field(1).Tag)

	println(" ----- ")



	//ValueOf 值类型的字段循环，打印字段值 以及反射设置值
	//判断属性值类型使用的是 TypeOf 的结构体实例的反射类型对象
	//根据字段的下表获取
	for s := 0; s < valOfCat.Elem().NumField(); s++ {
		field := valOfCat.Elem().Field(s)
		t_field := t.Elem().Field(s)
		//fmt.Println(valOfCat.Elem().Field(s))
		//fmt.Println(valOfCat.Elem().Field(s).Type())
		//fmt.Println(valOfCat.Elem().Field(s).Type().String())

		switch t_field.Type.Kind(){
		case reflect.String:
			field.SetString("设置的值哈哈哈哈")
		break
		case reflect.Int:
			//给字段设置值
			field.SetInt(18)
			break
		}

	}

	//打印设置后的值
	fmt.Println(ins)

}

可以看到设置成功