golang/go语言Go语言之反射
Posted 棉花糖灬
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了golang/go语言Go语言之反射相关的知识,希望对你有一定的参考价值。
本文参考了李文周的博客——Go语言基础之反射。
一、反射初识
1. 什么是反射
在计算机科学中,反射是指计算机程序在运行时(run time)可以访问、检测和修改它本身状态和行为的一种能力。用比喻来说,反射就是程序在运行的时候能够观察并修改自己的行为。
2. 使用场景
- 编写函数时,并不知道调用者传入的参数类型是什么,可能是没约定好,也可能是传入的类型很多,这些类型不能统一表示
- 有时候需要根据某些条件调用哪个函数,此时需要对函数和函数的参数进行反射,在运行期间动态的执行函数
3. 缺点
- 反射相关的代码难以阅读
- Go语言作为一门静态语言,在编码过程中可以发现一些类型错误,但对于反射代码则是无能为力的
- 反射对性能影响比较大,比正常代码运行速度慢一到两个数量级
二、reflect包
Go语言中的接口值都具有具体类型和具体类型的值两部分信息,而类型(Type)和值(Value)可以理解为定义在reflect包下的两个结构体reflect.Type和reflect.Value。
reflect包下有两个最基础的函数——TypeOf和ValueOf,分别用于获取对象的类型信息和值信息,也即reflect.Type和reflect.Value对象。
函数 | 说明 |
---|---|
func TypeOf(i any) Type | 获取对象的类型信息 |
func ValueOf(i any) Value | 获取对象的值信息 |
1. refelect.TypeOf函数
(1) TypeOf函数
通过relect.TypeOf()函数我们可以获取任意对象的类型信息,即reflect.Type对象。
package main
import (
"fmt"
"reflect"
)
func main()
var x float64 = 3.4
fmt.Println("type:",reflect.TypeOf(x)) //type: float64
(2) Type和Kind
反射中的类型可以分为类型(Type)和种类(Kind)两种。类型(Type)是在变量声明时被赋予的类型(静态类型)或者运行时的类型(动态类型,又称具体类型)。而种类(Kind)是指数据底层的类型,种类是有限可枚举的。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 // 底层指针
)
反射对象的Kind可以通过reflect.Value或reflect.Type类型对象的Kind()函数获取。reflect.Value或reflect.Type类型对象有很多同名函数,它们有些功能相同,有些在返回值有些许区别,本文后面对此有更多的例子。
2. reflect.ValueOf函数
(1) ValueOf函数
通过reflect.ValueOf()函数我们可以获取任意对象的值信息,即reflect.Value对象,其中包含了原始值的值信息。
package main
import (
"fmt"
"reflect"
)
func main()
var x float64 = 3.4
fmt.Println("value:",reflect.ValueOf(x)) //value: 3.4
(2) Value转为原始值
除了可以通过ValueOf()函数将原始值转为reflect.Value对象外,还可以将reflect.Value对象转为原始值,reflect.Value类型提供的获取原始值的方法如下:
方法 | 说明 |
---|---|
func (v Value) Interface() interface | 将值以 interface 类型返回,可以通过类型断言转换为指定类型 |
func (v Value) Int() int64 | 将值以 int 类型返回,所有有符号整型均可以此方式返回 |
func (v Value) Uint() uint64 | 将值以 uint 类型返回,所有无符号整型均可以此方式返回 |
func (v Value) Float() float64 | 将值以双精度(float64)类型返回,所有浮点数(float32、float64)均可以此方式返回 |
func (v Value) Bool() bool | 将值以 bool 类型返回 |
func (v Value) Bytes() []bytes | 将值以字节数组 []bytes 类型返回 |
func (v Value) String() string | 将值以字符串类型返回 |
可以发现通过Interface方法获取原始值的方式是最为通用的一种。
3. isNil和isValid方法
由于函数参数传递是值拷贝,所以必须传递变量的地址才能修改变量的值。在反射中可以使用Elem()方法来获取指针对应的值。
(1) isNil方法
func (v Value) IsNil() bool
IsNil()
报告v持有的值是否为nil,IsNil()
常被用于判断指针是否为空。。v持有的值的分类必须是通道、函数、接口、映射、指针、切片之一;否则IsNil函数会导致panic。
(2) isValid方法
func (v Value) IsValid() bool
IsValid()
返回v是否持有一个值,IsValid()
常被用于判定返回值是否有效。
(3) 代码示例
func main()
// *int类型空指针
var a *int
fmt.Println("var a *int IsNil:", reflect.ValueOf(a).IsNil())
// nil值
fmt.Println("nil IsValid:", 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.ValueOf("娜扎")).IsValid())
三、结构体反射
如果反射对象的类型是结构体,反射类型reflect.Type和反射值reflect.Value对象提供了对应的方法,来获取结构体的字段信息和方法信息,并且可以通过反射来调用结构体的方法。
1. 与结构体字段、方法相关的方法
下表中所列举的方法,除了Call()函数之外,其他的都是reflect.Value和reflect.Type都有的,只不过reflect.Value的同名函数返回结果的类型都是reflect.Value对象。
方法 | 说明 |
---|---|
func (t Type) Field(i int) StructField | 根据索引,返回索引对应的结构体字段的信息。 |
func (t Type) NumField() int | 返回结构体成员字段数量。 |
func (t Type) FieldByName(name string) (StructField, bool) | 根据给定字符串返回字符串对应的结构体字段的信息。 |
func (t Type) FieldByIndex(index []int) StructField | 多层成员访问时,根据 []int 提供的每个结构体的字段索引,返回字段的信息。 |
func (t Type) FieldByNameFunc(match func(string) bool) (StructField,bool) | 根据传入的匹配函数匹配需要的字段。 |
func (t Type) NumMethod() int | 返回该类型的方法集中方法的数目 |
func (t Type) Method(int) Method | 返回该类型方法集中的第i个方法 |
func (t Type) MethodByName(string) (Method, bool) | 根据方法名返回该类型方法集中的方法 |
func (v Value) Call([]Value) []Value | 根据传参调用结构体的方法 |
2. 获取结构体字段信息
(1) StructField类型
在上表中,有些方法的返回值类型为StructField类型,它是用来描述结构体的一个字段信息的,其定义如下:
type StructField struct
Name string // 字段的名字
PkgPath string // 非导出字段的包路径,对于导出字段该字段值为""
Type Type // 字段的类型
Tag StructTag // 字段的标签
Offset uintptr // 字段在结构体中的字节偏移量
Index []int // 用于Type.FieldByIndex时的索引
Anonymous bool // 是否匿名字段
(2) 获取结构体字段信息步骤
获取结构体字段信息可以分为以下几步:
- 先获取interface的reflect.Type,然后通过NumField进行遍历
- 再通过reflect.Type的Field方法根据下标获取其Field
- 最后通过reflect.Value的Field的Interface()得到对应的value
当然也可以使用FieldByName方法根据字段名获取字段信息。
2. 获取结构体方法信息
(1) Method类型
在上表中,有些方法的返回值类型为Method类型,它是用来描述结构体的一个方法信息的,其定义如下:
type Method struct
Name string // 方法名称
PkgPath string // 非导出方法的包路径,对于导出方法该字段值为""
Type Type // 方法类型
Func Value // 带有接收器作为第一个参数的方法
Index int // 用于Type.MethodByIndex时的索引
(2) 获取结构体方法信息步骤
获取结构体方法信息可以分为以下几步:
- 先获取interface的reflect.Type,然后通过NumMethod进行遍历
- 再通过reflect.Type的Method根据下标获取其Method
- 使用reflect.Value的Call函数调用结构体的Method
当然也可以使用MethodByName方法根据方法名获取方法信息。
3. 代码示例
package main
import (
"fmt"
"reflect"
)
// 定义一个结构体
type Person struct
Name string `json:"name"`
Age int `json:"age"`
Sex string `json:"sex"`
// 注意,如果是指针 *Person 类型,则不算做是 Person 的Method
func (p Person) PrintInfo()
fmt.Printf("name:%s, age:%d, sex:%s\\n", p.Name, p.Age, p.Sex)
func (p Person) Say(msg string)
fmt.Println("hello,", msg)
func main()
p := Person
Name: "zuzhiang",
Age: 27,
Sex: "female",
getFieldAndMethod(p)
// getFieldAndMethod 通过接口来获取任意参数,并打印结构体的字段和方法信息
func getFieldAndMethod(input interface)
getType := reflect.TypeOf(input) // 获取input的类型
fmt.Println("Type.Name: ", getType.Name()) // Person
fmt.Println("Type.Kind: ", getType.Kind()) // struct
getValue := reflect.ValueOf(input) // 获取input的值
fmt.Println("Value:", getValue) // zuzhiang 27 female
fmt.Println("----------------------------------------\\n")
// 获取结构体字段
// 1. 先获取interface的reflect.Type,然后通过NumField进行遍历
// 2. 再通过reflect.Type的Field方法根据下标获取其Field
// 3. 最后通过reflect.Value的Field的Interface()得到对应的value
for i := 0; i < getType.NumField(); i++
field := getType.Field(i)
value := getValue.Field(i).Interface() //获取第i个值
fmt.Printf("字段名: %s, 字段类型: %s, 字段索引: %d, json tag: %s, 字段值: %v \\n",
field.Name, field.Type, field.Index, field.Tag.Get("json"), value)
fmt.Println("----------------------------------------\\n")
// 定义函数调用时的参数,Call函数的参数类型必须是[]reflect.Value
msg := "zuzhiang"
paramList := make([]reflect.Value, 0)
paramList = append(paramList, reflect.ValueOf(msg))
args := [][]reflect.Value
nil,
paramList,
// 通过反射,操作方法
// 1. 先获取interface的reflect.Type,然后通过NumMethod进行遍历
// 2. 再通过reflect.Type的Method根据下标获取其Method
// 3. 使用reflect.Value的Call函数调用结构体的Method
for i := 0; i < getType.NumMethod(); i++
method := getType.Method(i)
fmt.Printf("方法名称: %s, 方法类型: %v \\n", method.Name, method.Type)
// 函数的顺序按函数名字典序正序排列
getValue.Method(i).Call(args[i])
fmt.Println("")
以上是关于golang/go语言Go语言之反射的主要内容,如果未能解决你的问题,请参考以下文章