Golang反射获取变量类型和值

1. 什么是反射

反射是程序在运行期间获取变量的类型和值、或者执行变量的方法的能力。

Golang反射包中有两对非常重要的函数和类型，两个函数分别是：

reflect.TypeOf 能获取类型信息reflect.Type；

reflect.ValueOf 能获取数据的运行时表示reflect.Value；

3. reflect.Type

Golang是一门静态类型的语言，反射是建立在类型之上的。

通过reflect.TypeOf() 函数可以获得任意值的类型信息。

3.1 类型`Type`和种类`Kind`

诸如int32, slice, map以及通过type关键词自定义的类型。

种类Kind可以理解为类型的具体分类。如int32、type MyInt32 int32是两种不同类型，但都属于int32这个种类。

使用 reflect.TypeOf()获取变量类型以及种类。

func main() {
type MyInt32 int32
a := MyInt32(1)
b := int32(1)
fmt.Printf("reflect.TypeOf(a):%v Kind:%v\n", reflect.TypeOf(a), reflect.TypeOf(a).Kind())
fmt.Printf("reflect.TypeOf(b):%v Kind:%v\n", reflect.TypeOf(b), reflect.TypeOf(b).Kind())
}

代码输出如下，由此可以看出int32、type MyInt32 int32是两种不同类型，但都属于int32这个种类。

$ go run main.go
reflect.TypeOf(a):main.MyInt32 Kind:int32
reflect.TypeOf(b):int32 Kind:int32

种类定义点击查看

// A Kind represents the specific kind of type that a Type represents.
// The zero Kind is not a valid kind.
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
Slice
String
Struct
UnsafePointer
)

3.2 引用指向元素的类型

// Elem returns a type's element type.
// It panics if the type's Kind is not Array, Chan, Map, Pointer, or Slice.
Elem() Type

部分情况我们需要获取指针指向元素的类型、或者slice元素的类型，可以reflect.Elem()函数获取。

func main() {
type myStruct struct {
}
a := &myStruct{}
typeA := reflect.TypeOf(a)
fmt.Printf("TypeOf(a):%v Kind:%v\n", typeA, typeA.Kind())
fmt.Printf("TypeOf(a).Elem():%v Elem().Kind:%v\n", typeA.Elem(), typeA.Elem().Kind())
s := []int64{}
typeS := reflect.TypeOf(s)
fmt.Printf("TypeOf(s):%v Kind:%v\n", typeS, typeS.Kind())
fmt.Printf("TypeOf(s).Elem():%v Elem().Kind:%v\n", typeS.Elem(), typeS.Elem().Kind())
}

代码输出如下，由此可以看出，通过reflect.Elem()函数可以获取引用指向数据的类型。

$ go run main.go
TypeOf(a):*main.myStruct Kind:ptr
TypeOf(a).Elem():main.myStruct Elem().Kind:struct
TypeOf(s):[]int64 Kind:slice
TypeOf(s).Elem():int64 Elem().Kind:int64

3.3 结构体成员类型

通过NumField获取成员数量，Field通过下标访问成员的类型信息StructField，包括成员名称、类型、Tag信息等。

func main() {
type secStruct struct {
Cnt []int64
}
type myStruct struct {
Num   int    `json:"num_json" orm:"column:num_orm"`
Desc  string `json:"desc_json" orm:"column:desc_orm"`
Child secStruct
}
s := myStruct{}
typeS := reflect.TypeOf(s)
// 成员数量
fmt.Printf("NumField:%v \n", typeS.NumField())
// 每个成员的信息 包括名称、类型、Tag
for i := 0; i < typeS.NumField(); i++ {
// 通过下标访问成员
fmt.Printf("Field(%v):%+v\n", i, typeS.Field(i))
}
// 通过名称访问成员
field, ok := typeS.FieldByName("Num")
fmt.Printf("FieldByName(\"Num\") ok:%v field:%+v\n", ok, field)
// 获取tag值
fmt.Printf("json tag val:%+v\n", field.Tag.Get("json"))
// 获取嵌套结构体的字段
fmt.Printf("Cnt field:%+v\n", typeS.FieldByIndex([]int{2, 0}))
}

代码输出如下，

$ go run main.go
NumField:3
Field(0):{Name:Num PkgPath: Type:int Tag:json:"num_json" orm:"column:num_orm" Offset:0 Index:[0] Anonymous:false}
Field(1):{Name:Desc PkgPath: Type:string Tag:json:"desc_json" orm:"column:desc_orm" Offset:8 Index:[1] Anonymous:false}
Field(2):{Name:Child PkgPath: Type:main.secStruct Tag: Offset:24 Index:[2] Anonymous:false}
FieldByName("Num") ok:true field:{Name:Num PkgPath: Type:int Tag:json:"num_json" orm:"column:num_orm" Offset:0 Index:[0] Anonymous:false}
json tag val:num_json
Cnt field:{Name:Cnt PkgPath: Type:[]int64 Tag: Offset:0 Index:[0] Anonymous:false}

4. reflect.Value

通过reflect.ValueOf获取变量值、值类型，种类为Array, Chan, Map, Slice, 或String可通过Len()获取长度

func main() {
b := int32(1)
valueB := reflect.ValueOf(b)
fmt.Printf("reflect.TypeOf(b):%v Kind:%v\n", valueB, valueB.Kind())
s := "abcdefg"
valueS := reflect.ValueOf(s)
fmt.Printf("reflect.TypeOf(s):%v Kind:%v Len:%v\n", valueS, valueS.Kind(), valueS.Len())
}

代码输出如下，

$ go run main.go
reflect.TypeOf(b):1 Kind:int32
reflect.TypeOf(s):abcdefg Kind:string Len:7

4.2 结构体的成员的值

和3.3 结构体成员类型获取结构体成员类型类似，reflect提供了NumField获取成员数量，Field通过下标访问成员的值。

func main() {
type secStruct struct {
Cnt []int64
}
type myStruct struct {
Num   int    `json:"num_json" orm:"column:num_orm"`
Desc  string `json:"desc_json" orm:"column:desc_orm"`
Child secStruct
}
s := myStruct{
Num:   100,
Desc:  "desc",
Child: secStruct{[]int64{1, 2, 3}},
}
valueS := reflect.ValueOf(s)
// 成员数量
fmt.Printf("NumField:%v \n", valueS.NumField())
// 每个成员的值
for i := 0; i < valueS.NumField(); i++ {
// 通过下标访问成员
fmt.Printf("value(%v):%+v\n", i, valueS.Field(i))
}
// 通过名称访问成员
value := valueS.FieldByName("Num")
fmt.Printf("FieldByName(\"Num\") value:%v\n", value)
// 获取嵌套结构体的字段
fmt.Printf("Cnt field:%+v\n", valueS.FieldByIndex([]int{2, 0}))
}

代码输出如下

$ go run main.go
NumField:3
value(0):100
value(1):desc
value(2):{Cnt:[1 2 3]}
FieldByName("Num") value:100
Cnt field:[1 2 3]

4.3 遍历array、slice

通过func (v Value) Index(i int) Value可以通过下标来访问Array, Slice,或者String各个元素的值。

func main() {
s := []int64{1, 2, 3, 4, 5, 6}
valueS := reflect.ValueOf(s)
fmt.Printf("ValueOf(s):%v Kind:%v Len:%v\n", valueS, valueS.Kind(), valueS.Len())
for i := 0; i < valueS.Len(); i++ {
fmt.Printf("valueS.Index(%v):%v\n", i, valueS.Index(i))
}
}

代码输出如下

$ go run main.go
ValueOf(s):[1 2 3 4 5 6] Kind:slice Len:6
valueS.Index(0):1
valueS.Index(1):2
valueS.Index(2):3
valueS.Index(3):4
valueS.Index(4):5
valueS.Index(5):6

4.4 遍历map

reflect有两种方法遍历map

通过迭代器MapIter遍历map
先获取map的所有key，再通过key获取对应的value

func main() {
m := map[int]string{
1: "1",
2: "2",
3: "3",
}
valueM := reflect.ValueOf(m)
// 迭代器访问
iter := valueM.MapRange()
for iter.Next() {
fmt.Printf("key:%v val:%v\n", iter.Key(), iter.Value())
}
fmt.Println("------")
// 通过key访问
keys := valueM.MapKeys()
for i := 0; i < len(keys); i++ {
fmt.Printf("key:%v val:%v\n", keys[i], valueM.MapIndex(keys[i]))
}
}

代码输出如下，

$ go run main.go
key:1 val:1
key:2 val:2
key:3 val:3
------
key:3 val:3
key:1 val:1
key:2 val:2

5. 反射的三大定律

反射的两个基础函数定义，

获取类型func TypeOf(i any) Type
获取值func ValueOf(i any) Value

其中，any是interface{}的别名。

interface{}是不包含任何方法签名的空接口，任何类型都实现了空接口。

A value of interface type can hold any value that implements those methods.

因此，interface{}可以承载任何变量的 (value, concrete type)信息。

5.1 从interface到反射对象

interface{}承载变量的(value, concrete type)信息，通过反射暴露方法来访问interface{}的值和类型。

可以简单理解为interface{}的值和信息传递到reflect.Type和reflect.Value，方便获取。

5.2 从反射对象到interface

可以通过函数func (v Value) Interface() (i any)将反射对象转换为interface{}，

是func ValueOf(i any) Value的反向操作。

func main() {
a := int32(10)
valueA := reflect.ValueOf(a)
fmt.Printf("ValueOf(a):%v\n", valueA)
fmt.Printf("Interface():%v\n", valueA.Interface())
ai, ok := valueA.Interface().(int32)
fmt.Printf("ok:%v val:%v\n", ok, ai)
}

代码输出如下

$ go run main.go
ValueOf(a):10
Interface():10
ok:true val:10

5.3 通过反射修改对象，该对象值必须是可修改的

reflect提供func (v Value) CanSet() bool判断对象值是否修改，通过func (v Value) Set(x Value)修改对象值

func main() {
a := int32(10)
valueA := reflect.ValueOf(a)
fmt.Printf("valueA :%v\n", valueA.CanSet())
b := int32(100)
valuePtrB := reflect.ValueOf(&b)
fmt.Printf("valuePtrB:%v Elem:%v\n", valuePtrB.CanSet(), valuePtrB.Elem().CanSet())
valuePtrB.Elem().Set(reflect.ValueOf(int32(200)))
fmt.Printf("b:%v Elem:%v\n", b, valuePtrB.Elem())
}

代码输出如下

$ go run main.go
valueA :false
valuePtrB:false Elem:true
b:200 Elem:200

后续章节再分享通过修改各种类型的值的实操。

5. 参考文档

laws-of-reflection

interface

标签 GO, 类型, 获取

Golang反射获取变量类型和值

1. 什么是反射

3. reflect.Type

3.1 类型Type和种类Kind

3.2 引用指向元素的类型

3.3 结构体成员类型

4. reflect.Value

4.2 结构体的成员的值

4.3 遍历array、slice

4.4 遍历map

5. 反射的三大定律

5.1 从interface到反射对象

5.2 从反射对象到interface

5.3 通过反射修改对象，该对象值必须是可修改的

5. 参考文档

3.1 类型`Type`和种类`Kind`