go语言之反射(二)_北洛-编程思维

反射的值对象

反射不仅可以获取值的类型信息,还可以动态地获取或者设置变量的值。Go语言中使用reflect.Value获取和设置变量的值。

使用反射值对象包装任意值

Go语言中,使用reflect.ValueOf()函数获得值的反射值对象(reflect.Value)。书写格式如下:

value := reflect.ValueOf(rawValue)

  

reflect.ValueOf返回reflect.Value类型,包含有rawValue的值信息。reflect.Value与原值间可以通过值包装和值获取互相转化。reflect.Value是一些反射操作的重要类型,如反射调用函数。

从反射值对象获取被包装的值

Go 语言中可以通过 reflect.Value 重新获得原始值。

1.从反射值对象(reflect.Value)中获取值的方法

可以通过下面几种方法从反射值对象 reflect.Value 中获取原值,如表1-2所示。

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

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

package main

import (
	"fmt"
	"reflect"
)

func main() {

	// 声明整型变量a并赋初值
	var a int = 1024

	// 获取变量a的反射值对象
	valueOfA := reflect.ValueOf(a)

	// 获取interface{}类型的值, 通过类型断言转换
	var getA int = valueOfA.Interface().(int)

	// 获取64位的值, 强制类型转换为int类型
	var getA2 int = int(valueOfA.Int())

	fmt.Println(getA, getA2)
}

  

代码输出如下:

1024 1024

  

代码说明如下:

  • 第11行,声明一个变量,类型为int,设置初值为1024。
  • 第14行,获取变量a的反射值对象,类型为reflect.Value,这个过程和reflect.TypeOf()类似。
  • 第17行,将valueOfA反射值对象以interface{}类型取出,通过类型断言转换为int类型并赋值给getA。
  • 第20行,将valueOfA反射值对象通过Int方法,以int64类型取出,通过强制类型转换,转换为原本的int类型。

使用反射访问结构体成员字段的值

反射值对象(reflect.Value)提供对结构体访问的方法,通过这些方法可以完成对结构体任意值的访问,如表1-3所示。

表1-3   反射值对象的成员访问方法
方法 备注
Field(i int) Value 根据索引,返回索引对应的结构体成员字段的反射值对象。当值不是结构体或索引超界时发生宕机
NumField() int 返回结构体成员字段数量。当值不是结构体或索引超界时发生宕机
FieldByName(name string) Value 根据给定字符串返回字符串对应的结构体字段。没有找到时返回零值,当值不是结构体或索引超界时发生宕机
FieldByIndex(index []int) Value 多层成员访问时,根据[]int提供的每个结构体的字段索引,返回字段的值。 没有找到时返回零值,当值不是结构体或索引超界时发生宕机
FieldByNameFunc(match func(string) bool) Value 根据匹配函数匹配需要的字段。找到时返回零值,当值不是结构体或索引超界时发生宕机

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

反射访问结构体成员值:

package main

import (
    "fmt"
    "reflect"
)

// 定义结构体
type dummy struct {
    a int
    b string

    // 嵌入字段
    float32
    bool

    next *dummy
}


func main() {

    // 值包装结构体
    d := reflect.ValueOf(dummy{
            next: &dummy{},
    })

    // 获取字段数量
    fmt.Println("NumField", d.NumField())

    // 获取索引为2的字段(float32字段)
    floatField := d.Field(2)

    // 输出字段类型
    fmt.Println("Field", floatField.Type())

    // 根据名字查找字段
    fmt.Println("FieldByName(\"b\").Type", d.FieldByName("b").Type())

    // 根据索引查找值中, next字段的int字段的值
    fmt.Println("FieldByIndex([]int{4, 0}).Type()", d.FieldByIndex([]int{4, 0}).Type())
}

  

代码说明如下:

  • 第9行,定义结构体,结构体的每个字段的类型都不一样。
  • 第24行,实例化结构体并包装为reflect.Value类型,成员中包含一个*dummy的实例。
  • 第29行,获取结构体的字段数量。
  • 第32和35行,获取索引为2的字段值(float32字段),并且打印类型。
  • 第38行,根据b字符串,查找到b字段的类型。
  • 第41行,[]int{4, 0}中的4表示,在dummy结构中索引值为4的成员,也就是next。next的类型为dummy,也是一个结构体,因此使用[]int{4, 0}中的0继续在next值的基础上索引,结构为dummy中索引值为0的a字段,类型为int。

 

代码输出如下:

NumField 5
Field float32
FieldByName("b").Type string
FieldByIndex([]int{4, 0}).Type() int

  

反射对象的空和有效性判断

反射值对象(reflect.Value)提供一系列方法进行零值和空判定,如表1-4所示。

反射值对象的零值和有效性判断方法
方法 说明
IsNil() bool 如果值类型不是通道(channel)、函数、接口、map、指针或切片时发生 panic,类似于语言层的v == nil操作
IsValid() bool 判断值是否有效。当值本身非法时,返回false,例如reflect Value不包含任何值,值为nil等。

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

反射值对象的零值和有效性判断:

package main

import (
	"fmt"
	"reflect"
)

func main() {

	// *int的空指针
	var a *int
	fmt.Println("<1> var a *int:", reflect.ValueOf(a).IsNil())

	// nil值
	fmt.Println("<2> nil:", reflect.ValueOf(nil).IsValid())

	// *int类型的空指针
	fmt.Println("<3> (*int)(nil):", reflect.ValueOf((*int)(nil)).Elem().IsValid())

	// 实例化一个结构体
	s := struct{}{}

	// 尝试从结构体中查找一个不存在的字段
	fmt.Println("<4> 不存在的结构体成员:", reflect.ValueOf(s).FieldByName("").IsValid())

	// 尝试从结构体中查找一个不存在的方法
	fmt.Println("<5> 不存在的结构体方法:", reflect.ValueOf(s).MethodByName("").IsValid())

	// 实例化一个map
	m := map[int]int{}

	// 尝试从map中查找一个不存在的键
	fmt.Println("<6> 不存在的键:", reflect.ValueOf(m).MapIndex(reflect.ValueOf(3)).IsValid())
}

    

代码说明如下:

  • 第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,并且返回查找到的结果。

代码输出如下:

<1> var a *int: true
<2> nil: false
<3> (*int)(nil): false
<4> 不存在的结构体成员: false
<5> 不存在的结构体方法: false
<6> 不存在的键: false

  

使用反射对象修改变量的值 

使用reflect.Value对包装的值进行修改时,需要遵循一些规则。如果没有按照规则进行代码设计和编写,轻则无法修改对象值,重则程序在运行时会发生宕机。

1.判定及获取元素的相关方法
使用reflect.Value取元素、取地址及修改值的属性方法请参考表1-5。

表1-5   反射值对象的判定及获取元素的方法
方法名 备注
Elem() Value 取值指向的元素值,类似于语言层*操作。当值类型不是指针或接口时发生宕 机,空指针时返回nil的Value
Addr() Value 对可寻址的值返回其地址,类似于语言层&操作。当值不可寻址时发生宕机
CanAddr() bool 表示值是否可寻址
CanSet() bool 返回值能否被修改。要求值可寻址且是导出的字段

2.值修改相关方法
使用reflect.Value修改值的相关方法如表1-6所示。

表1-6
Set(x Value) 将值设置为传入的反射值对象的值
Setlnt(x int64) 使用int64设置值。当值的类型不是int、int8、int16、int32、int64时会发生宕机
SetUint(x uint64) 使用uint64设置值。当值的类型不是uint、uint8、uint16、uint32、uint64时会发生宕机
SetFloat(x float64) 使用float64设置值。当值的类型不是float32、float64时会发生宕机
SetBool(x bool) 使用bool设置值。当值的类型不是bod时会发生宕机
SetBytes(x []byte) 设置字节数组[]bytes值。当值的类型不是[]byte时会发生宕机
SetString(x string) 设置字符串值。当值的类型不是string时会发生宕机

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

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

package main

import (
    "reflect"
)

func main() {

    // 声明整型变量a并赋初值
    var a int = 1024

    // 获取变量a的反射值对象
    valueOfA := reflect.ValueOf(a)

    // 尝试将a修改为1(此处会发生崩溃)
    valueOfA.SetInt(1)
}

  

程序运行崩溃,打印错误:

panic: reflect: reflect.Value.SetInt using unaddressable value

  

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

package main

import (
	"fmt"
	"reflect"
)

func main() {

	// 声明整型变量a并赋初值
	var a int = 1024

	// 获取变量a的反射值对象(a的地址)
	valueOfA := reflect.ValueOf(&a)

	// 取出a地址的元素(a的值)
	valueOfA = valueOfA.Elem()

	// 修改a的值为1
	valueOfA.SetInt(1)

	// 打印a的值
	fmt.Println(valueOfA.Int())
}

  

代码输出如下:

1

  

  • 第14行中,将变量a取值后传给reflect.ValueOf()。此时reflect.ValueOf()返回的valueOfA持有变量a的地址。
  • 第17行中,使用reflect.Value类型的Elem()方法获取a地址的元素,也就是a的值。reflect.Value的Elem()方法返回的值类型也是reflect.Value。
  • 第20行,此时valueOfA表示的是a的值且可以寻址。使用SetInt()方法设置值时不再发生崩溃。
  • 第23行,正确打印修改的值。

提示:当reflect.Value不可寻址时,使用Addr()方法也是无法取到值的地址的,同时会发生宕机。虽然说reflect.Value的Addr()方法类似于语言层的&操作;Elem()方法类似于语言层的*操作,但并不代表这些方法与语言层操作等效。

4.值可修改条件之一:被导出
结构体成员中,如果字段没有被导出,即便不使用反射也可以被访问,但不能通过反射修改,代码如下:

package main

import (
	"reflect"
)

func main() {

	type dog struct {
		legCount int
	}
	// 获取dog实例的反射值对象
	valueOfDog := reflect.ValueOf(dog{})

	// 获取legCount字段的值
	vLegCount := valueOfDog.FieldByName("legCount")

	// 尝试设置legCount的值(这里会发生崩溃)
	vLegCount.SetInt(4)
}

  

程序发生崩溃,报错:

panic: reflect: reflect.Value.SetInt using value obtained using unexported field

 

报错的意思是:SetInt()使用的值来自于一个未导出的字段。为了能修改这个值,需要将该字段导出。将dog中的legCount的成员首字母大写,导出LegCount让反射可以访问,修改后的代码如下:

type dog struct {
    LegCount int
}

  

然后根据字段名获取字段的值时,将字符串的字段首字母大写,修改后的代码如下:

vLegCount := valueOfDog.FieldByName("LegCount")

  

再次运行程序,发现仍然报错:

panic: reflect: reflect.Value.SetInt using unaddressable value

  

这个错误表示第13行构造的valueOfDog这个结构体实例不能被寻址,因此其字段也不能被修改。修改代码,取结构体的指针,再通过reflect.Value的Elem()方法取到值的反射值对象。修改后的完整代码如下: 

package main

import (
    "reflect"
    "fmt"
)

func main() {

    type dog struct {
            LegCount int
    }
    // 获取dog实例地址的反射值对象
    valueOfDog := reflect.ValueOf(&dog{})

    // 取出dog实例地址的元素
    valueOfDog = valueOfDog.Elem()

    // 获取legCount字段的值
    vLegCount := valueOfDog.FieldByName("LegCount")

    // 尝试设置legCount的值(这里会发生崩溃)
    vLegCount.SetInt(4)

    fmt.Println(vLegCount.Int())
}

  

代码输出如下:

4

  

代码说明如下:

  • 第11行,将LegCount首字母大写导出该字段。
  • 第14行,获取dog实例指针的反射值对象。
  • 第17行,取dog实例的指针元素,也就是dog的实例。
  • 第20行,取dog结构体中LegCount字段的成员值。
  • 第23行,修改该成员值。
  • 第25行,打印该成员值。

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

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

通过类型创建类型的实例

当已知reflect.Type时,可以动态地创建这个类型的实例,实例的类型为指针。例如reflect.Type的类型为int时,创建int的指针,即*int,代码如下:

package main

import (
    "fmt"
    "reflect"
)

func main() {

    var a int

    // 取变量a的反射类型对象
    typeOfA := reflect.TypeOf(a)

    // 根据反射类型对象创建类型实例
    aIns := reflect.New(typeOfA)

    // 输出Value的类型和种类
    fmt.Println(aIns.Type(), aIns.Kind())
}

  

代码输出如下:

*int ptr

  

代码说明如下:

  • 第13行,获取变量a的反射类型对象。
  • 第16行,使用reflect.New()函数传入变量a的反射类型对象,创建这个类型的实例值,值以reflect.Value类型返回。这步操作等效于:new(int),因此返回的是*int类型的实例。
  • 第19行,打印aIns的类型为*int,种类为指针。

使用反射调用函数

如果反射值对象(reflect.Value)中值的类型为函数时,可以通过reflect.Value调用该函数。使用反射调用函数时,需要将参数使用反射值对象的切片[]reflect.Value构造后传入Call()方法中,调用完成时,函数的返回值通过[]reflect.Value返回。

下面的代码声明一个加法函数,传入两个整型值,返回两个整型值的和。将函数保存到反射值对象(reflect.Value)中,然后将两个整型值构造为反射值对象的切片([]reflect.Value),使用Call()方法进行调用。

反射调用函数:

package main

import (
    "fmt"
    "reflect"
)

// 普通函数
func add(a, b int) int {

    return a + b
}

func main() {

    // 将函数包装为反射值对象
    funcValue := reflect.ValueOf(add)

    // 构造函数参数, 传入两个整型值
    paramList := []reflect.Value{reflect.ValueOf(10), reflect.ValueOf(20)}

    // 反射调用函数
    retList := funcValue.Call(paramList)

    // 获取第一个返回值, 取整数值
    fmt.Println(retList[0].Int())
}

  

代码说明如下:

  • 第9~12行,定义一个普通的加法函数。
  • 第17行,将add函数包装为反射值对象。
  • 第20行,将10和20两个整型值使用reflect.ValueOf包装为reflect.Value,再将反射值对象的切片[]reflect.Value作为函数的参数。
  • 第23行,使用funcValue函数值对象的Call()方法,传入参数列表paramList调用add()函数。
  • 第26行,调用成功后,通过retList[0]取返回值的第一个参数,使用Int取返回值的整数值。

提示:反射调用函数的过程需要构造大量的reflect.Value和中间变量,对函数参数值进行逐一检查,还需要将调用参数复制到调用函数的参数内存中。调用完毕后,还需要将返回值转换为reflect.Value,用户还需要从中取出调用值。因此,反射调用函数的性能问题尤为突出,不建议大量使用反射函数调用。

版权声明:本文版权归作者所有,遵循 CC 4.0 BY-SA 许可协议, 转载请注明原文链接
https://www.cnblogs.com/beiluowuzheng/p/9904949.html