Go--反射

变量的内在机制

• Go语言中的变量是分为两部分的:

  • 类型信息：预先定义好的元信息。
  • 值信息：程序运行过程中可动态变化的。

反射介绍

• 反射是指在程序运行期对程序本身进行访问和修改的能力。程序在编译时，变量被转换为内存地址，变量名不会被编译器写入到可执行部分。在运行程序时，程序无法获取自身的信息。

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

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

• 反射就是在运行时动态的获取一个变量的类型信息和值信息。（应用在不清楚需要传入的数据的具体类型的情况下，通过反射，可以进行判断）

reflect包

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

1、TypeOf

• 在Go语言中，使用reflect.TypeOf()函数可以获得任意值的类型对象（reflect.Type），程序通过类型对象可以访问任意值的类型信息。
• 可以实现接口类型断言的效果

1.1、TypeOf() 方法获取接口数据类型

func reflectType(x interface{
   }) {
   
	v := reflect.TypeOf(x)
	fmt.Printf("type:%v\n", v)
}
func main() {
   
	var a float32 = 3.14
	reflectType(a) // type:float32
	var b int64 = 100
	reflectType(b) // type:int64
}

2.1、type name和type kind

• 在反射中关于类型还划分为两种：类型（Type）和种类（Kind）。type是定义的类型，而kind是指底层的类型
• 因为在Go语言中我们可以使用type关键字构造很多自定义类型，而种类（Kind）就是指底层的类型，但在反射中，当需要区分指针、结构体等大品种的类型时，就会用到种类（Kind）

示例：

type myInt int64

func reflectType(x interface{
   }) {
   
	t := reflect.TypeOf(x)
	fmt.Printf("type:%v kind:%v\n", t.Name(), t.Kind())
}

func main() {
   
	var a *float32 // 指针
	var b myInt    // 自定义类型
	var c rune     // 类型别名
	reflectType(a) // type: kind:ptr
	reflectType(b) // type:myInt kind:int64
	reflectType(c) // type:int32 kind:int32

	type person struct {
   
		name string
		age  int
	}
	type book struct{
    title string }
	var d = person{
   
		name: "小王",
		age:  18,
	}
	var e = book{
   title: "《Let's Go》"}
	// 如下，这个两个不同类型的结构体，他们的kind都是属于struct。
	reflectType(d) // type:person kind:struct
	reflectType(e) // type:book kind:struct
}

• Go语言的反射中像数组、切片、Map、指针等类型的变量，它们的.Name()都是返回空。

在reflect包中定义的Kind类型如下：

type Kind uint
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        // 底层指针
)

2、ValueOf

• 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	将值以字符串类型返回

2.1、通过反射获取值

func reflectValue(x interface{
   }) {
   
	v := reflect.ValueOf(x)
	k := v.Kind() // 值的种类
	switch k {
   
	case reflect.Int64:
		/* reflect.ValueOf()取的整数和浮点数值只有int和float类型,因此int64或者float32需要先取值后转换*/
		// v.Int()从反射中获取整型的原始值，然后通过int64()强制类型转换
		fmt.Printf("type is int64, value is %d\n", int64(v.Int()))
	case reflect.Float32:
		// v.Float()从反射中获取浮点型的原始值，然后通过float32()强制类型转换
		fmt.Printf("type is float32, value is %f\n", float32(v.Float()))
	case reflect.Float64:
		// v.Float()从反射中获取浮点型的原始值，然后通过float64()强制类型转换
		fmt.Printf