Go语言反射reflect标准库03-通过反射获取值信息相关操作

通过反射获取值信息

1. 当我们将一个接口值传递给一个 reflect.ValueOf 函数调用时，此调用返回的是代表着此接口值的动态值的一个 reflect.Value 值。我们必须通过间接的途径获得一个代表一个接口值的 reflect.Value 值。
   一个reflect.Value值的CanSet方法将返回此reflect.Value值代表的go值是否可以被修改（可以被赋值），如果一个go值可以被修改，则我们可以调用reflect.Value值的Set方法来修改此go值。
   注意：reflect.ValueOf函数返回的reflect.Value值都是不可以被修改的。
2. 反射不仅可以获取值的类型信息，还可以动态的获取或者修改变量的值，go语言中可以通过reflect.Value函数获取或者修改变量的值。
3. 使用反射对象包装任意值
   在go语言中，使用reflect.ValueOf()函数可以获取值的反射对象（reflect.Value）,
   reflect.ValueOf 返回 reflect.Value 类型，包含有 rawValue 的值信息。reflect.Value 与原值间可以通过值包装和值获取互相转化。reflect.Value 是一些反射操作的重要类型，如反射调用函数。
4. 从反射对象获取被包装的值
   go语言中可以通过reflect.Value重新获取原始值
5. 从反射对象(reflect.Value)中获取值的方法
   可以通过下面几种方法从反射对象reflect.Value中获取原值：

6. 从反射对象reflect.Value中获取值的例子
   下面代码中，将整型变量中的值使用 reflect.Value 获取反射值对象（reflect.Value）。再通过 reflect.Value 的 Interface() 方法获得 interface{} 类型的原值，通过 int 类型对应的 reflect.Value 的 Int() 方法获得整型值。

func main() {
	var a int = 1024
	// 获取反射值对象
	valueOfA := reflect.ValueOf(a)
	// 获取interface{}类型的值，通过类型断言转换
	getA := valueOfA.Interface().(int)
	// 获取64位的值，强制类型转换为int类型
	getA2 := int(valueOfA.Int())
	fmt.Println(getA, getA2)  // 1024 1024
}

通过反射访问结构体成员的值

反射值对象（reflect.Value）提供对结构体访问的方法，通过这些方法可以完成对结构体任意值的访问，如下表所示。
反射值对象的成员访问方法

下面代码构造一个结构体包含不同类型的成员。通过 reflect.Value 提供的成员访问函数，可以获得结构体值的各种数据。
反射访问结构体成员值：

func main() {
	// 获取结构体反射值对象
	valueOfDummy := reflect.ValueOf(dummy{next: &dummy{}})
	// 获取字段数量
	fmt.Println(valueOfDummy.NumField())
	// 获取索引为2的字段（float32字段）,并输出字段类型
	fmt.Println(valueOfDummy.Field(2).Type())
	// 根据名字查找字段
	fmt.Println(valueOfDummy.FieldByName("b").Type())
	// 根据索引查找值中next字段的int字段的值
	fmt.Println(valueOfDummy.FieldByIndex([]int{4, 0}).Type())
}
/* 输出结果
5
float32
string
int
*/

判断反射值的空和有效性

反射值对象（reflect.Value）提供一系列方法进行零值和空判定，如下表所示。
反射值对象的零值和有效性判断方法

下面的例子将会对各种方式的空指针进行 IsNil() 和 IsValid() 的返回值判定检测。同时对结构体成员及方法查找 map 键值对的返回值进行 IsValid() 判定，参考下面的代码。
反射值对象的零值和有效性判断：

func main() {
	// *int的空指针
	var a *int
	fmt.Println(reflect.ValueOf(a).IsNil())  // true
	// nil值
	fmt.Println(reflect.ValueOf(a).IsValid())  // true
	fmt.Println(reflect.ValueOf(nil).IsValid())  // false
	// *int类型的空指针
	fmt.Println(reflect.ValueOf((*int)(nil)).IsValid())  // true
	fmt.Println(reflect.ValueOf((*int)(nil)).Elem().IsValid())  // false
	// 实例化一个结构体
	s := struct {}{}
	// 尝试从结构体中查找一个不存在的字段
	fmt.Println(reflect.ValueOf(s).FieldByName("").IsValid())  // false
	// 尝试从结构体中查找一个不存在的方法
	fmt.Println(reflect.ValueOf(s).MethodByName("").IsValid())  // false
	// 实例化一个map
	m := map[int]int{}
	// 尝试从map中查找一个不存在的键
	fmt.Println(reflect.ValueOf(m).MapIndex(reflect.ValueOf(3)).IsValid())  // false
}

代码说明如下：

第 11 行，声明一个 *int 类型的指针，初始值为 nil。
第 12 行，将变量 a 包装为 reflect.Value 并且判断是否为空，此时变量 a 为空指针，因此返回 true。
第 15 行，对 nil 进行 IsValid() 判定（有效性判定），返回 false。
第 18 行，(int)(nil) 的含义是将 nil 转换为 int，也就是int 类型的空指针。此行将 nil 转换为 int 类型，并取指针指向元素。由于 nil 不指向任何元素，*int 类型的 nil 也不能指向任何元素，值不是有效的。因此这个反射值使用 Isvalid() 判断时返回 false。
第 21 行，实例化一个结构体。
第 24 行，通过 FieldByName 查找 s 结构体中一个空字符串的成员，如成员不存在，IsValid() 返回 false。
第 27 行，通过 MethodByName 查找 s 结构体中一个空字符串的方法，如方法不存在，IsValid() 返回 false。
第 30 行，实例化一个 map，这种写法与 make 方式创建的 map 等效。
第 33 行，MapIndex() 方法能根据给定的 reflect.Value 类型的值查找 map，并且返回查找到的结果。

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

通过反射获取结构体方法并调用

type Student struct {
	Name string
	Score int
}
// Run 注意：此处有一个关键，实现了值接收者会自动实现指针接受者，实现了指针接受者不会自动实现值接收者
func (s Student) Run(abc int, def string){
	fmt.Println(abc, def)
	fmt.Println("Run运行了...")
}

func main() {
	s := Student{"马亚南", 100}
	// 注意：此处有一个关键，实现了值接收者会自动实现指针接受者，实现了指针接受者不会自动实现值接收者
	valueOfStudent := reflect.ValueOf(&s)
	run := valueOfStudent.MethodByName("Run")
	args := []reflect.Value{reflect.ValueOf(123), reflect.ValueOf("哈哈哈")}
	run.Call(args)
}

输出结果：

123 哈哈哈
Run运行了...

通过反射修改变量的值

Go语言中类似 x、x.f[1] 和 *p 形式的表达式都可以表示变量，但是其它如 x + 1 和 f(2) 则不是变量。一个变量就是一个可寻址的内存空间，里面存储了一个值，并且存储的值可以通过内存地址来更新。
对于 reflect.Values 也有类似的区别。有一些 reflect.Values 是可取地址的；其它一些则不可以。考虑以下的声明语句：

x := 2 // value type variable?
a := reflect.ValueOf(2) // 2 int no
b := reflect.ValueOf(x) // 2 int no
c := reflect.ValueOf(&x) // &x *int no
d := c.Elem() // 2 int yes (x)

其中 a 对应的变量则不可取地址。因为 a 中的值仅仅是整数 2 的拷贝副本。b 中的值也同样不可取地址。c 中的值还是不可取地址，它只是一个指针 &x 的拷贝。
实际上所有通过reflect.ValueOf(x)返回的reflect.Value都是不可寻地址的，但是对于d，它是c的解引用方式生成的，指向另外一个变量，因此是可寻地址的，
我们可以通过调用reflect.ValueOf(&x).Elem()来获取任意变量x对应的可寻地址Value
我们可以通过调用reflect.CanAddr方法来判断其是否可以被寻地址

func main() {
	x := 1
	a := reflect.ValueOf(2)
	b := reflect.ValueOf(x)
	c := reflect.ValueOf(&x)
	d := c.Elem()

	fmt.Println(a.CanAddr())  // false
	fmt.Println(b.CanAddr())  // false
	fmt.Println(c.CanAddr())  // false
	fmt.Println(d.CanAddr())  // false
}

每当我们通过指针间接地获取的 reflect.Value 都是可取地址的，即使开始的是一个不可取地址的 Value。在反射机制中，所有关于是否支持取地址的规则都是类似的。例如，slice 的索引表达式 e[i]将隐式地包含一个指针，它就是可取地址的，即使开始的e表达式不支持也没有关系。
以此类推，reflect.ValueOf(e).Index(i) 对于的值也是可取地址的，即使原始的 reflect.ValueOf(e) 不支持也没有关系。
使用 reflect.Value 对包装的值进行修改时，需要遵循一些规则。如果没有按照规则进行代码设计和编写，轻则无法修改对象值，重则程序在运行时会发生宕机。
2. 判定以获取元素的相关方法
使用 reflect.Value 取元素、取地址及修改值的属性方法请参考下表。
反射值对象的判定及获取元素的方法

3. 值修改相关方法
   使用 reflect.Value 修改值的相关方法如下表所示。
   反射值对象修改值的方法

以上方法，在 reflect.Value 的 CanSet 返回 false 仍然修改值时会发生宕机。
在已知值的类型时，应尽量使用值对应类型的反射设置值。

4. 值可修改条件之一-可被寻址
   通过反射修改变量值的前提条件之一：这个值必须可以被寻址。简单地说就是这个变量必须能被修改。示例代码如下：

func main() {
	var a int = 1
	valueOfA := reflect.ValueOf(a)
	valueOfA.SetInt(88)
	fmt.Println(a)
}

程序运行崩溃：panic: reflect: reflect.Value.SetInt using unaddressable value
报错的意思是:SetInt 正在使用一个不能被寻址的值。从 reflect.ValueOf 传入的是 a 的值，而不是 a 的地址，这个 reflect.Value 当然是不能被寻址的。将代码修改一下，重新运行：

func main() {
	var a int = 1
	valueOfA := reflect.ValueOf(&a)
	// 取出a地址的元素，然后修改a的值
	valueOfA.Elem().SetInt(88)
	fmt.Println(a)  // 88
}

注意：当 reflect.Value 不可寻址时，使用 Addr() 方法也是无法取到值的地址的，同时会发生宕机。虽然说 reflect.Value 的 Addr() 方法类似于语言层的&操作；Elem() 方法类似于语言层的*操作，但并不代表这些方法与语言层操作等效。
5. 值可修改条件之二：被导出
结构体成员中，如果字段没有被导出，即便不使用反射也可以被访问，但不能通过反射修改，代码如下：

func main() {
	type dog struct {
		legCount int
	}
	myDog := dog{}
	valueOfDog := reflect.ValueOf(myDog)
	valueOfDog.FieldByName("legCount").SetInt(55)
	fmt.Println(myDog)
}

程序发生崩溃
panic: reflect: reflect.Value.SetInt using value obtained using unexported field
报错的意思是：SetInt() 使用的值来自于一个未导出的字段。

为了能修改这个值，需要将该字段导出。将 dog 中的 legCount 的成员首字母大写，导出 LegCount 让反射可以访问，修改后的代码如下：

func main() {
	type dog struct {
		LegCount int
	}
	myDog := dog{}
	valueOfDog := reflect.ValueOf(myDog)
	valueOfDog.FieldByName("LegCount").SetInt(55)
	fmt.Println(myDog)
}

再次运行程序，发现仍然报错：
panic: reflect: reflect.Value.SetInt using unaddressable value
这个错误表示第 13 行构造的 valueOfDog 这个结构体实例不能被寻址，因此其字段也不能被修改。修改代码，取结构体的指针，再通过 reflect.Value 的 Elem() 方法取到值的反射值对象。修改后的完整代码如下：

func main() {
	type dog struct {
		LegCount int
	}
	myDog := dog{}
	valueOfDog := reflect.ValueOf(&myDog)
	valueOfDog.Elem().FieldByName("LegCount").SetInt(55)
	fmt.Println(myDog)
}

值的修改从表面意义上叫可寻址，换一种说法就是值必须“可被设置”。那么，想修改变量值，一般的步骤是：

取这个变量的地址或者这个变量所在的结构体已经是指针类型。
使用 reflect.ValueOf 进行值包装。
通过 Value.Elem() 获得指针值指向的元素值对象（Value），因为值对象（Value）内部对象为指针时，使用 set 设置时会报出宕机错误。
使用 Value.Set 设置值。