Go 反射
目录
什么是反射
反射的弊端
reflect 包
Go 提供的反射方法
type Type 类型
type Kind 类型
TypeOf
ValueOf
什么是反射
反射（reflection）是在 Java 出现后迅速流行起来的一种概念，通过反射可以获取丰富的类型信息，并可以利用这些类型信息做非常灵活的工作。大多数现代的高级语言都以各种形式支持反射功能，反射是把双刃剑，功能强大但代码可读性并不理想，若非必要并不推荐使用反射。
反射可以在程序编译期将变量的反射信息，如字段名称、类型信息、结构体信息等整合到可执行文件中，并给程序提供接口访问反射信息，这样就可以在程序运行期获取类型的反射信息，并且有能力修改它们。
反射的弊端
- 代码难以阅读和维护。
- 编译期间不能发现类型错误，有些bug只能在运行很长时间才能发现，可能造成不良后果。
- 反射性能差，通常比正常代码慢一到两个数量级。在对性能要求高或大量反复调用的代码块里建议不要使用反射。
reflect 包
Go语言中的反射是由 reflect 包提供支持的，它定义了两个重要的类型 Type 和 Value 任意接口值在反射中都可以理解为由 reflect.Type 和 reflect.Value 两部分组成，并且 reflect 包提供了 reflect.TypeOf 和 reflect.ValueOf 两个函数来获取任意对象的 Value 和 Type。
Go 提供的反射方法
GoLang reflect 反射官网
type Type 类型
type Type interface {
// 在内存中分配时，返回此类型值的对齐方式（以字节为单位）
Align() int
// 当用作结构体中的字段时，返回此类型值的对齐方式（以字节为单位）。
FieldAlign() int
// 返回结构体中的第 i 个方法
Method(i int) Method
// 返回结构体中指定的方法，并返回是否找到该方法的bool值
MethodByName(string) (Method, bool)
// 返回可访问的方法数量
NumMethod() int
// 返回结构体名称
Name() string
// 返回包路径
PkgPath() string
// 返回类型存储所占用的直接大小
Size() uintptr
// 返回类型的字符串表示形式。字符串表示可以使用缩短的包名称，并且不能保证在类型之间是唯一的。要测试类型标识，请直接比较类型。
String() string
// 返回此类型的特定种类
Kind() Kind
// 判断是否实现了指定的接口u
Implements(u Type) bool
// 判断类型的值是否可分配给u类型
AssignableTo(u Type) bool
// 判断类型的值是否可转换为u类型，即使返回true，也可能会宕机，转换类型(切片)长度小于被转换类型的长度可能会宕机
ConvertibleTo(u Type) bool
// 判断此类型的值是否具有可比性。即使Comparable返回true，这种比较仍可能引发宕机。例如，接口类型的值是可比较的，但如果它们的动态类型不可比较，则比较会死机
Comparable() bool
// 返回类型的字节大小
Bits() int
// 返回通道类型的方向。如果这个类型的Kind不是Chan，会宕机
ChanDir() ChanDir
// 判断函数输入类型
IsVariadic() bool
// 返回指针类型的数据类型。如果类型的Kind不是Array、Chan、Map、Pointer或Slice，则会引发宕机
Elem() Type
// 返回结构体种的第 i 个字段
Field(i int) StructField
// 返回与索引相对应的嵌套字段
FieldByIndex(index []int) StructField
// 返回具有给定名称的结构字段，并返回一个布尔值，指示是否找到该字段。
FieldByName(name string) (StructField, bool)
// 以广度优先的顺序考虑结构本身中的字段，然后考虑任何嵌入结构中的字段。在最浅的嵌套深度处停止，嵌套深度包含一个或多个满足匹配函数的字段。如果该深度的多个字段满足匹配函数，则它们会相互抵消，FieldByNameFunc不会返回匹配。此行为反映了Go对包含嵌入字段的结构中的名称查找的处理
FieldByNameFunc(match func(string) bool) (StructField, bool)
// 返回函数类型的第i个输入参数的类型
In(i int) Type
// 返回映射类型的键类型。如果类型的Kind不是Map，会宕机
Key() Type
// 返回数组类型的长度
Len() int
// 返回结构类型的字段数量
NumField() int
// 返回函数类型的输入参数数量
NumIn() int
// 返回函数类型的输出参数数量
NumOut() int
// 返回函数类型的第i个输出参数的类型
Out(i int) Type
}type Kind 类型
Kind表示type所表示的特定类型。
type Kind uint
const (
Invalid Kind = iota
Bool
Int
Int8
Int16
Int32
Int64
Uint
Uint8
Uint16
Uint32
Uint64
Uintptr
Float32
Float64
Complex64
Complex128
Array
Chan
Func
Interface
Map
Pointer // ptr
Slice
String
Struct
UnsafePointer
)
TypeOf
| func TypeOf(i any) Type | 返回 i 的反射Type类型。如果 i 的值是nil接口，TypeOf返回nil。(返回Type类型后，返回值可以使用上面 type Type interface的方法) |
示例1 reflect.TypeOf 的使用
func getType() {
typeInt := reflect.TypeOf(1)
fmt.Println(typeInt) // 打印 int
fmt.Println(typeInt.String()) // 打印 int
fmt.Println(typeInt.Kind()) // 打印 int
typeString := reflect.TypeOf("hello")
fmt.Println(typeString) // 打印 string
fmt.Println(typeString.String()) // 打印 string
fmt.Println(typeString.Kind()) // 打印 string
}示例2 reflect.TypeOf 的使用
// 自定义一个数据类型
type User struct {
UserName string `我是Tag`
Age int
}
func getType() {
var u1 User
typeUser1 := reflect.TypeOf(u1)
fmt.Println(typeUser1) // 打印 main.User
fmt.Println(typeUser1.String()) // 打印 main.User
fmt.Println(typeUser1.Kind()) // 打印 struct
fmt.Println(typeUser1.Field(0).Name) // 打印 UserName
var u2 = new(User)
typeUser2 := reflect.TypeOf(u2)
fmt.Println(typeUser2) // 打印 *main.User
fmt.Println(typeUser2.String()) // 打印 *main.User
fmt.Println(typeUser2.Kind()) // 打印 ptr
var u3 = new(User)
typeUser3 := reflect.TypeOf(u3).Elem() // Elem():把指针类型转成普通类型
fmt.Println(typeUser3) // 打印 main.User
fmt.Println(typeUser3.String()) // 打印 main.User
fmt.Println(typeUser3.Kind()) // 打印 struct
}示例3 获取成员变量详细信息
type User struct {
UserName string `我是Tag`
Age int
student Student
}
type Student struct {
score float32
}
func getField() {
typeUser := reflect.TypeOf(User{})
// 获取成员变量详情
numField := typeUser.NumField()
for i := 0; i < numField; i++ {
field := typeUser.Field(i)
fmt.Println("成员变量详情：", field)
}
// 获取结构体中嵌套结构体student中的变量score
subField := typeUser.FieldByIndex([]int{2, 0}) // []int{2,0} 2是student在User中的下标，0是score在Student中的下标
fmt.Println(subField)
}示例4 获取成员方法详细信息
type User struct {
UserName string `我是Tag`
Age int
}
func (User) Insert() int {
return 1
}
// 获取成员方法，不是指针方法，如果需要获取指针方法，需要reflect.TypeOf(&User{})取地址才可
func getMethod() {
typeUser := reflect.TypeOf(User{})
numMethod := typeUser.NumMethod()
for i := 0; i < numMethod; i++ {
method := typeUser.Method(i)
fmt.Println("成员方法详情：", method)
}
}示例5 获取方法入参出参详细信息
func Add(a, b int) int {
return a + b
}
// 获取普通方法详情
func getFunc() {
typeFunc := reflect.TypeOf(Add)
fmt.Println("方法类型：", typeFunc.Kind())
numIn := typeFunc.NumIn()
fmt.Println("方法输入参数个数：", numIn)
numOut := typeFunc.NumOut()
fmt.Println("方法输出参数个数：", numOut)
for i := 0; i < numIn; i++ {
fmt.Printf("第 %d 个输入参数类型是 %s \n", i, typeFunc.In(i))
}
for i := 0; i < numOut; i++ {
fmt.Printf("第 %d 个输出参数类型是 %s \n", i, typeFunc.Out(i))
}
}ValueOf
| func ValueOf(i any) Value | 返回一个新值，初始化为存储在接口中的具体值。ValueOf(nil)返回零。 |
| func (v Value) Type() Type | 返回v的Type类型。 |
| func (v Value) Kind() Kind | 返回v的类型。如果v是零值（IsValid返回false），Kind返回Invalid。 |
| func (v Value) Addr() Value | 返回一个表示v的地址的指针值 // 把普通类型转成指针类型。 |
| func (v Value) CanAddr() bool | 判断该值的地址是否可以通过Addr获取。这样的值称为可寻址值。如果值是切片的一个元素，可寻址数组的一个元素，可寻址结构的一个字段，或者指针解引用(elem)的结果，那么它就是可寻址的。如果CanAddr返回false，则调用Addr会出现panic。//是可寻址值的数据才能通过反射进行修改。 |
| func (v Value) CanSet() bool | 判断v的值是否可以更改。只有当Value是可寻址的并且不是通过使用未导出(未导出就是首字符小写的意思)的结构字段获得时，才能更改它。如果CanSet返回false，则调用Set或任何类型特定的setter（例如，SetBool、SetInt）将panic。 |
| func (v Value) Elem() Value | 返回接口v包含的值或指针v所指向的值。如果v的类型不是接口或指针，它会panic。如果v为nil，则返回0值。// 把指针类型转成普通类型。 |
| func (v Value) Interface() (i any) | 返回v的当前值作为interface{}。它相当于：var i interface{} |
| func (v Value) IsValid() bool | 报告v是否代表一个值。如果v为零值，则返回false。// var i interface{};fmt.Println(reflect.ValueOf(i).IsValid()) 返回false |
| func (v Value) IsNil() bool | 判断参数v是否为空。参数必须是chan、func、interface、map、pointer或slice值 |
| func (v Value) IsZero() bool | 判断v是否为其类型的零值。 |
| func (v Value) Index(i int) Value | 返回v的第i个元素，是可寻址值。如果v的类型不是数组、切片或字符串，或者i超出了范围，它就会panic。 |
| func (v Value) Set(x Value) | 将x赋值给v。如果CanSet返回false，它会panic。x的值Value类型，并且未导出的字段不能赋值。// 设置复合数据类型的时候使用 |
| func (v Value) SetInt(x int64) | 将v的底层值设置为x，如果v的Kind不是Int、Int8、Int16、Int32或Int64，或者CanSet（）为false，则会panic。 |
| func (v Value) SetString(x string) | 将v的底层值设置为x。如果v的Kind不是String或CanSet（）为false，则会panic。 |
| func (v Value) FieldByName(name string) Value | 返回名称为name的结构体字段。如果未找到字段，则返回零值。如果v的Kind不是结构体，它会panic。 |
| func (v Value) Len() int | 返回v的长度。如果v的Kind不是Array、Chan、Map、Slice、String或指向Array的指针，它会panic。 |
| func (v Value) SetLen(n int) | 将v的长度设置为n。如果v的Kind不是Slice，或者n为负数或大于Slice的cap，则会panic。 |
| func (v Value) SetCap(n int) | 将v的容量设置为n。如果v的Kind不是Slice，或者n小于Slice的len或大于Slice的原来的cap，则会panic。 |
| func (v Value) MapIndex(key Value) Value | 返回v中的键关联的值。如果v的Kind不是map，则会宕机。如果在映射中找不到键，或者如果v表示nil映射，则返回零值。与Go中一样，键的值必须可分配给映射的键类型。 |
| func (v Value) SetMapIndex(key, elem Value) | 将v中与key相关联的元素设置为elem。如果v的Kind不是Map，它会宕机。如果elem是零值，则SetMapIndex会从映射中删除该键。否则，如果v持有nil映射，则SetMapIndex将宕机。elem的键值对类型必须和v的Map键值对类型保持一致。 |
| func (v Value) Send(x Value) | 在通道v上发送x，阻塞的。如果v的Kind不是Chan，或者x的类型与v的元素类型不同，它会宕机。与Go一样，x的值必须是可分配给通道的元素类型(类型要一样)。 |
| func (v Value) TrySend(x Value) bool | 尝试在信道v上发送x，但不会阻塞。如果v的Kind不是Chan，它会宕机。它返回是否发送了值。与Go一样，x的值必须是可分配给通道的元素类型。 |
| func (v Value) Recv() (x Value, ok bool) | 从通道v接收并返回一个值。如果v的Kind不是Chan，它会宕机。接收将阻塞，直到值准备好为止。如果值x对应于通道上的发送，则布尔值ok为true，如果由于通道关闭而接收到零值，则为false。 |
| func (v Value) TryRecv() (x Value, ok bool) | 尝试从信道v接收值，但不会阻塞。如果v的Kind不是Chan，它会宕机。如果receive传递了一个值，那么x是传递的值，ok为true。如果接收不能在无阻塞的情况下完成，则x为零值，ok为false。如果通道是关闭的，则x是通道元素类型的零值，ok为false。 |
| func (v Value) Call(in []Value) []Value | 调用函数v。如果v的Kind不是Func，则会panic。它将输出结果作为Value切片返回。与Go一样，每个输入参数都必须可分配给函数对应输入参数的类型。如果v是一个可变函数，Call会创建可变分片参数，复制相应的值。 |
| func (v Value) MethodByName(name string) Value | 返回name对应的v中的方法。对返回函数调用的参数不应包括接收器；返回的函数将始终使用v作为接收器。如果没有找到任何方法，它将返回零值。 |
| func New(typ Type) Value | 返回一个值，该值表示指向指定类型的新零值的指针。也就是说，返回的Value的Type是PointerTo（典型值）// 就是创建一个对象的Kind类型。 |
| func MakeSlice(typ Type, len, cap int) Value | 创建一个指定类型、长度和容量的新的初始化为零的切片。 |
| func MakeMap(typ Type) Value | 创建指定类型的map。 |
| func MakeMapWithSize(typ Type, n int) Value | 创建一个n容量的指定类型的map。 |
| func MakeChan(typ Type, buffer int) Value | 创建一个指定类型和缓冲区大小的新通道。 |
| 更多API介绍，请查阅官网 | https://golang.google.cn/pkg/reflect |
示例1 reflect.ValueOf 的使用
func getValue() {
intValue := reflect.ValueOf(1)
stringValue := reflect.ValueOf("hello")
userValue := reflect.ValueOf(User{})
fmt.Println(intValue) // 打印 1
fmt.Println(stringValue) // 打印 hello
fmt.Println(userValue) // 打印 { 0}
}示例2 Value 转 Type
func getValue() {
intValue := reflect.ValueOf(1)
// Value 转 Type
intType := intValue.Type()
fmt.Println(intType)
}示例3 指针结构体互相转换
func trans() {
userValue := reflect.ValueOf(&User{})
fmt.Println(userValue.Kind()) // 打印 ptr
// 指针 转成 结构体
userValuePtr := userValue.Elem()
fmt.Println(userValuePtr.Kind()) // 打印 struct
// 结构体 转成 指针
userValue2 := userValuePtr.Addr()
fmt.Println(userValue2.Kind()) // 打印 ptr
}示例4 反射类型转普通类型
func trans() {
iValue := reflect.ValueOf(1)
// 方式一：把 反射类型转成普通类型
iValue.Int()
// 方式二：把 反射类型转成普通类型
iValue2 := iValue.Interface().(int)
fmt.Println(iValue2)
// 把 反射类型 转成 结构体类型
userType := reflect.ValueOf(User{})
user := userType.Interface().(User)
fmt.Println(user.UserName)
}示例5 通过反射修改基础类型的值
func changeValue() {
var i = 10
iValue := reflect.ValueOf(&i)
fmt.Println(iValue.Kind()) // 打印 ptr
// 判断是否是可寻址值
if iValue.CanAddr() {
iValue.SetInt(20)
fmt.Println("i = ", i) // if 进不来，无打印
}
// 通过 elem 把指针类型解析成反射类型。注意：elem 只能被指针类型的反射所调用，所以在ValueOf的时候带&取址符号
iValue2 := iValue.Elem()
fmt.Println(iValue2.Kind()) // 打印 int
// 判断是否是可寻址值
if iValue2.CanAddr() {
iValue2.SetInt(30)
fmt.Println("i = ", i) // 打印 30
}
}示例6 通过反射修改结构体成员变量的值
type User struct {
UserName string `我是Tag`
Age int
gender int // 首字母小写是未导出字段，反射不能修改未导出字段
}
func changeValue() {
var user = User{
UserName: "张三",
Age: 18,
}
fmt.Println("修改前的值：", user.UserName, user.Age) // 打印 张三 18
userValue := reflect.ValueOf(&user).Elem()
if userValue.CanAddr() {
userValue.FieldByName("UserName").SetString("李四")
userValue.FieldByName("Age").SetInt(28)
fmt.Println("修改后的值：", user.UserName, user.Age) // 打印 李四 28
}
}示例7 通过反射修改嵌套结构体成员变量的值
type User struct {
UserName string `我是Tag`
Age int
gender int
Student Student
}
type Student struct {
Score float32
}
func changeValue() {
var user = User{
UserName: "张三",
Student: Student{
Score: 98,
},
}
userValue := reflect.ValueOf(&user).Elem()
if userValue.CanAddr() {
studentValue := userValue.FieldByName("Student")
fmt.Println(studentValue.Kind()) // 打印 struct
// 修改 Score 的值
studentValue.FieldByName("Score").SetFloat(59)
fmt.Println(user.Student.Score) // 打印 59
}
}示例8 通过反射修改 slice 切片中的值
type User struct {
UserName string `我是Tag`
Age int
gender int // 首字母小写是未导出字段，反射不能修改未导出字段
}
func changeValue() {
var userSlice = make([]*User, 3, 5)
userSlice[0] = &User{
UserName: "张三",
Age: 18,
}
fmt.Println("修改前的数据：", userSlice[0].UserName, userSlice[0].Age) // 打印 张三 18
sliceValue := reflect.ValueOf(userSlice)
// 判断是否是可寻址的
fmt.Println(sliceValue.CanAddr()) // 打印 false
if sliceValue.Len() > 0 {
// 获取切片中第0个元素
sliceValue0 := sliceValue.Index(0)
// 判断是否是可寻址的
fmt.Println(sliceValue0.CanAddr()) // 打印 true
// 查看是否是指针类型，如果是指针类型，需要 elem 解析
fmt.Println(sliceValue0.Kind()) // 打印 ptr 是指针类型
userValue := sliceValue0.Elem()
userValue.FieldByName("UserName").SetString("李四")
userValue.FieldByName("Age").SetInt(28)
fmt.Println("修改后的数据：", userSlice[0].UserName, userSlice[0].Age) // 打印 李四 28
}
// 直接修改整个 user 对象
sliceValue.Index(1).Set(reflect.ValueOf(&User{
UserName: "王五",
Age: 16,
}))
fmt.Println(userSlice[1].UserName, userSlice[1].Age) // 打印 王五 16
}示例9 通过反射修改 map 中的值
func changeValue() {
u1 := &User{
UserName: "张三",
Age: 18,
}
u2 := &User{
UserName: "李四",
Age: 20,
}
// 定义一个map对象
userMap := make(map[int]*User, 5)
userMap[0] = u1
userMap[1] = u2
// 反射value对象
mapValue := reflect.ValueOf(userMap)
// 把value类型转成type类型
mapType := mapValue.Type()
// 获取map中 key 的数据类型
keyType := mapType.Key()
fmt.Println("key的数据类型是：", keyType) // 打印 int
// 获取map中 value 的数据类型。 注意这里的 elem 是 Type 的方法，作用是获取mapType的元素类型，不是解析指针
valueType := mapType.Elem()
fmt.Println("value的数据类型是：", valueType) //打印 *main.User
// 修改 map中映射对应的值中的某一个成员变量的数据，比如只修改用户的年龄
u1Value := mapValue.MapIndex(reflect.ValueOf(1)) // 修改map中key是1的数据
fmt.Println("修改前的数据：", userMap[1].UserName, userMap[1].Age) // 打印 李四 20
u1Value.Elem().FieldByName("Age").SetInt(28)
fmt.Println("修改后的数据：", userMap[1].UserName, userMap[1].Age) // 打印 李四 28
// 通过反射设置map的键值对
k3 := 2
u3 := &User{
UserName: "王五",
Age: 22,
}
mapValue.SetMapIndex(reflect.ValueOf(k3), reflect.ValueOf(u3))
fmt.Println(userMap[k3].UserName, userMap[k3].Age) // 打印 王五 22
}示例10 通过反射操作channel管道类型数据
func changeValue() {
// 定义一个 chan 的数据
var ch = make(chan int, 8)
// 向 chan 中写入一行数据
ch <- 10
// 反射chan类型
chanValue := reflect.ValueOf(&ch).Elem()
if chanValue.CanAddr() {
// 读取 chan 管道中的数据
fmt.Println(chanValue.Recv())
}
// 向 chan 管道中写入数据
chanValue.Send(reflect.ValueOf(20))
// 获取把反射类型，转成普通类型
c := chanValue.Interface().(chan int)
fmt.Println(<-c)
}示例11 通过反射调用普通方法
func callFunc() {
valueFunc := reflect.ValueOf(Add)
fmt.Println(valueFunc.Kind()) // 打印 func
typeFunc := valueFunc.Type()
numIn := typeFunc.NumIn() // 获取参数个数
// 定义函数实参
params := make([]reflect.Value, numIn)
for i := 0; i < numIn; i++ {
params[i] = reflect.ValueOf(1)
}
// 通过反射调用函数，返回切片Value，返回值中是函数返回结果
callResult := valueFunc.Call(params)
for i := 0; i < len(callResult); i++ {
// 打印返回结果 // 实际开发中这里可以使用类型判断
fmt.Println(callResult[i])
}
}示例12 通过反射调用结构体的成员方法
type User struct {
UserName string `我是Tag`
Age int
gender int
Student Student
}
func (User) Insert(userName string) int {
return 1
}
func callFunc() {
user := &User{}
userValue := reflect.ValueOf(user)
// 通过方法名称获取结构体中的方法
insertMethod := userValue.MethodByName("Insert")
// 调用方法，返回函数结果
callResult := insertMethod.Call([]reflect.Value{reflect.ValueOf("张三")})
for i := 0; i < len(callResult); i++ {
// 打印返回结果
fmt.Println(callResult[i])
}
}示例13 通过反射创建结构体对象实例
func newStruct() {
u := reflect.TypeOf(User{})
// new一个对象的指针
value := reflect.New(u)
// 赋值
value.Elem().FieldByName("UserName").SetString("张三")
// 赋值
value.Elem().FieldByName("Age").SetInt(18)
// 反射类型转普通类型
user := value.Interface().(*User)
fmt.Println(user.UserName, user.Age) // 打印 张三 18
}示例14 通过反射创建slice切片实例
func newSlice() {
var slice []User
sliceType := reflect.TypeOf(slice)
// 创建一个指针类型的切片
sliceValue := reflect.MakeSlice(sliceType, 3, 5)
sliceValue.Index(0).Set(reflect.ValueOf(User{
UserName: "张三",
Age: 18,
}))
// 把反射的类型转成 普通类型
users := sliceValue.Interface().([]User)
for _, user := range users {
fmt.Println(user.UserName, user.Age) // 打印 张三 18，0，0
}
}示例15 通过反射创建map实例
func newMap() {
var userMap map[int]*User
mapType := reflect.TypeOf(userMap)
// 创建map
mapValue := reflect.MakeMap(mapType)
//reflect.MakeMapWithSize(mapType,5) // 指定容量
// 给对象赋值
u := &User{
UserName: "张三",
Age: 18,
}
mapValue.SetMapIndex(reflect.ValueOf(0), reflect.ValueOf(u))
mp := mapValue.Interface().(map[int]*User)
// 遍历对象
for k, v := range mp {
fmt.Printf("下标：%d, 数据：%s %d", k, v.UserName, v.Age)
}
}示例16 通过反射创建channel管道实例
func newChannel() {
var ch chan User
chanType := reflect.TypeOf(ch)
// 创建 chan 对象
chanValue := reflect.MakeChan(chanType, 5)
u := User{
UserName: "张三",
Age: 18,
}
// 向 chan 中添加数据
chanValue.Send(reflect.ValueOf(u))
// 将反射类型转成普通类型
c := chanValue.Interface().(chan User)
fmt.Println(<-c)
}全套教程地址：Golang全套教程