Go语言反射

反射

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

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

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

使用：空接口可以存储任意类型的变量，通过反射在运行时动态获取一个变量的类型信息和值信息。

reflect包

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

TypeOf

Go语言中，使用reflect.TypeOf()函数可以获得任意值类型的对象(reflect.Type)，程序通过类型对象可以访问任意值的类型信息。

type name 和 type kind

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

package main

import(
	"fmt"
    "reflect"
)

type Cat struct{}

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

func main(){
    var cat = Cat{}
    reflectType(cat)
    // type: main.Cat
    // type name: Cat, type kind: struct
}

ValueOf

reflect.ValueOf()返回的是reflect.Value类型，包含了原始值的信息。reflect.Value与原始值直接可以互换。

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

方法	说明
Interface() interface{}	将值以interface{}类型返回，可以通过类型断言转化为相应的类型
Int() int64	将值以int类型返回，所有有符号整型均以此形式返回
Unit() unit64	将值以uint类型返回，所有无符号整型均以此方式返回
Float() float64	将值以双精度float64类型返回，所有浮点数均以次方式返回
Bool() bool	将值以boo类型返回
Bytes() []bytes	将值以字节数组[]bytes类型返回
String() string	将值以字符串类型返回

package main

import (
	"fmt"
	"reflect"
)

func reflectValue(x interface{})  {
	v := reflect.ValueOf(x)
	k := v.Kind()
	switch k {
	case reflect.Int64:
		fmt.Printf("type is int64, value is %d\n", v.Int())
	case reflect.Float32:
		fmt.Printf("type is float32m value is %f\n", float32(v.Float()))
	case reflect.Float64:
		fmt.Printf("type is float64, value is %f\n", v.Float())
	}
}

func main() {
	var a float32 = 3.14
	var b int64 = 100
	reflectValue(a)
	reflectValue(b)
	c := reflect.ValueOf(10)
	fmt.P rintf("type c: %T\n", c)
}

通过反射设置变量的值

想要在函数中通过反射修改变量的值，需要注意函数传递的是值拷贝，必须借助变量地址才能修改变量的值。而反射中使用专有的Elem()方法来获取指针对应的值。

package main

import (
	"fmt"
	"reflect"
)

func reflectValueInt(x interface{}){
	v := reflect.ValueOf(x)
	if v.Kind() == reflect.Int64{
		v.SetInt(200)  // 修改的是副本，reflect包会引发panic
        // panic: reflect: reflect.Value.SetInt using unaddressable value
	}
}

func reflectValuePtr(x interface{}){
	v := reflect.ValueOf(x)
	// 反射中利用Elem()方法获取指针对应的值
	if v.Elem().Kind() == reflect.Int64{
		v.Elem().SetInt(200)
	}
}

func main() {
	var intValue int64 = 100
	//reflectValueInt(intValue)  // panic
	reflectValuePtr(&intValue)
}

isNil()

func (v Value) IsNil() bool 
// 报告持有的值是否为nil。v持有的值的分类必须为通道、函数、接口、映射、指针、切片之一；否则报panic

isValid()

func (v Value) IsValid() bool
// 返回v是否持有一个值。如果v是Value零值会返回假，此时v除了IsValid、String、Kind之外的方法都会报panic

IsNil()常用于判断指针是否为空；IsValid()常用于判定返回值是否有效。

func main(){
	// *int指针
    var a *int
    fmt.Println("var a *int isNil: ", reflect.ValueOf(a).IsNil())
    // nil值
    fmt.Println("nil valid: ", reflect.valueOf(nil).IsValid())
    // 实例化一个匿名结构体
    b := struct{}{}
    // 尝试从结构体中查找"abc"字段
    fmt.Println("不存在结构体成员：", reflect.ValueOf(b).FieldByName("abc").IsValid())
    // 尝试从结构体中查找"abc方法"
    fmt.Println("不存在结构体方法：", reflect.ValueOf(b).MethodByName("abc").IsValid())
    // map
    c := map[string]int{}
    // 尝试从map中查找一个不存在的键
    fmt.Println("map中不存在的键："， reflect.ValueOf(c).MapIndex(reflect.Value("abc")).IsValid())
}

结构体反射

与结构体相关的方法：

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

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)	根据方法名返回该类型方法集中的方法

StructField类型

StructField类型用来描述结构体中的一个字段的信息。

StructField的定义如下：

type StructField struct{
    Name string  // 字段的名字
    PkgPath string  // 非导出字段的路径，对导出字段该字段为""
    Type Type  // 字段的类型
    Tag StructTag  // 字段的标签
    Offset uintptr  // 字段在结构体中的偏移量
    Index []int  // 用于Type.FieldByIndex时的索引切片
    Anonymous bool  // 是否匿名字段
}

例：

package main

import (
	"fmt"
	"reflect"
)

type student struct {
	Name string `json:"Name" zhoulin:"周琳"`
	Score int `json:"Score" zhoulin:"周琳"`
}

func main(){
	stu := student{
		Name: "小王子",
		Score: 90,
	}

	t := reflect.TypeOf(stu)
	fmt.Println(t.Name(), t.Kind())  // student struct

	// 通过for循环遍历结构体的所有字段信息
	for i:= 0; i < t.NumField(); i++{
		field := t.Field(i)
		fmt.Printf("name: %s index: %d type: %v json tag: %v\n", field.Name, field.Index, field.Type, field.Type)
	}

	// 通过字段名获取指定结构体字段信息
	if scoreFiled, Ok := t.FieldByName("Score"); Ok{
		fmt.Printf("name: %s index: %d type: %v json tag: %v\n", scoreFiled.Name, scoreFiled.Index,
			scoreFiled.Type, scoreFiled.Type)
	}
}

反射的利弊

反射是一个强大并富有表现力的工具，能让我们写出更灵活的代码。但是反射不能被滥用，原因：

1. 基于反射的代码是极其脆弱的，反射中的类型错误会在真正运行时才会引发panic，那很可能在代码写完后的很长时间之后
2. 大量使用反射的代码通常难以理解
3. 反射的性能十分低下，基于反射实现的代码通常比正常的代码运行速度慢一到两个数量级