Go 语言是静态类型的，每个变量在编译期有且只能有一个确定的、已知的类型，即变量的静态类型。静态类型在变量声明的时候就已经确定了，无法修改。
那么为什么我们还需要反射呢？这是因为有些事情只有在运行时才知道。比如你定义了一个函数，它有一个interface{}类型的参数，这也就意味着调用者可以传递任何类型的参数给这个函数。在这种情况下，如果你想知道调用者传递的是什么类型的参数，就需要用到反射。如果你想知道一个结构体有哪些字段和方法，也需要反射。
在Go语言的反射定义中，任何接口都由两部分组成：接口的具体类型，以及具体类型对应的值。在Go反射中，标准库提供了两种类型reflect.Value和reflect.Type来分别表示变量的值和类型，并且提供了两个函数reflect.ValueOf和reflect.TypeOf分别获取任意对象的reflect.Value和reflect.Type。
reflect.Value
Value结构代表接口的值，定义中都是小写，因此主要看Value的具体方法，Value的方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
|
type Value struct {
//typ_ 保存由 value 表示的值的类型。
//使用 typ 方法访问以避免 v 的转义。
typ_ *abi.Type
//指针值数据，或者，如果设置了 flagIndir，则为指向数据的指针。
//当 flagIndir 被设置或 typ.pointers（）为true时有效。
ptr unsafe.Pointer
//标志保存有关该值的元数据。
//最低的五位给出值的种类，镜像类型。Kind（）。
//下一组位是标志位：
//-flagStickyRO：通过未过期未嵌入字段获取，因此为只读
//-flagEmbedRO: 通过未导出的嵌入字段获取，因此为只读
//-flagIndir: val持有指向数据的指针
//-flagAddr: v.CanAddr为true（表示flagIndir和ptr为非零）
//-flagMethod: v是一个方法值。
//如果ifaceIndir（typ），代码可以假设flagIndir已设置。
//剩下的22+位给出了方法值的方法编号。
//If flag.kind（）！=Func，代码可以假设flagMethod是未设置的。
flag
//方法值表示当前的方法调用
//类似r。读取某些接收器r。典型值+val+标志位描述
//接收器r，但标志的Kind位表示Func（方法为
//函数），并且标志的顶部位给出方法编号
//在r的类型的方法表中。
}
type flag uintptr
|
reflect.Type
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
|
type Type interface {
// 返回值的对齐方式（以字节为单位）
// 用作在内存中分配时
Align() int
// 返回值的对齐方式（以字节为单位）
// 用作结构中的字段
FieldAlign() int
// 返回已定义类型的包中的类型名称
Name() string
// 返回定义类型的包路径，即导入路径
PkgPath() string
// 返回存储所需的字节数
Size() uintptr
// 返回该类型的字符串表示形式
String() string
Implements(u Type) bool
AssignableTo(u Type) bool
ConvertibleTo(u Type) bool
Comparable() bool
// 以位为单位返回类型的大小
Bits() int
// 返回通道类型的方向
ChanDir() ChanDir
// 报告函数类型的最终输入参数
IsVariadic() bool
// 返回函数类型的第i个输入参数的类型
In(i int) Type
// 返回映射类型的键类型
Key() Type
// 返回数组类型的长度
Len() int
// 返回函数类型的输入参数计数
NumIn() int
// 返回函数类型的输出参数计数
NumOut() int
// 返回函数类型的第i个输出参数的类型
Out(i int) Type
// 以下这些方法与 Value 结构体的功能相同
Kind() Kind
Method(int) Method
MethodByName(string) (Method, bool)
NumMethod() int
Elem() Type
Field(i int) StructField
FieldByIndex(index []int) StructField
FieldByName(name string) (StructField, bool)
FieldByNameFunc(match func(string) bool) (StructField, bool)
NumField() int
}
|
反射定律
反射是计算机语言中程序检视其自身结构的一种方法，它属于元编程的一种形式。反射灵活、强大，但也存在不安全因素。它可以绕过编译器的很多静态检查，如果过多使用便会造成混乱。为了帮助开发者更好地理解反射，Go语言的作者在博客上总结了反射的三大定律。
- 任何接口值interface{}都可以反射出反射对象，也就是reflect.Value和reflect.Type通过函数reflect.ValueOf和reflect.TypeOf获得。
- 反射对象也可以还原为interface{}变量，也就是第1条定律的可逆性，通过reflect.Value结构体的Interface方法获得。
- 要修改反射的对象，该值必须可设置，也就是可寻址
提示
- 任何类型的变量都可以转换为空接口intferface{}
- 所以第1条定律中函数reflect.ValueOf和reflect.TypeOf的参数就是interface{}，表示可以把任何类型的变量转换为反射对象。
- 在第2条定律中，reflect.Value结构体的Interface方法返回的值也是interface{}，表示可以把反射对象还原为对应的类型变量。
在反射中，reflect.Value对应的是变量的值，如果你需要进行与变量的值有关的操作，应该优先使用reflect.Value，比如获取变量的值、修改变量的值等。reflect.Type对应的是变量的类型，如果你需要进行与变量的类型本身有关的操作，应该优先使用reflect.Type，比如获取结构体内的字段、类型拥有的方法集等。
使用示例
通过 reflect.Type 中的Implements 可以判断是否实现了某接口。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
|
package main
import (
"fmt"
"io"
"reflect"
)
type persion struct {
Name string `json:"name"`
Age int `json:"age"`
}
// 为 persion 增加一个方法 String ，返回对应的字符串信息
// 这样 persion 结构体就实现了 fmt.Stringer 接口
func (p persion) String() string {
return fmt.Sprintf("Name is %s, Age is %d", p.Name, p.Age)
}
func main() {
p := persion{
Name: "码一行",
Age: 26,
}
pt := reflect.TypeOf(p)
stringerType := reflect.TypeOf((*fmt.Stringer)(nil)).Elem()
writerType := reflect.TypeOf((*io.Writer)(nil)).Elem()
fmt.Println("是否实现了 fmt.Stringer: ", pt.Implements(stringerType))
fmt.Println("是否实现了 io.Writer: ", pt.Implements(writerType))
}
|
通过 reflect.Type 实现一个contains逻辑，可以传入的字符串、map、数组、切片。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
|
func Contains(in interface{}, elem interface{}) bool {
inValue := reflect.ValueOf(in)
elemValue := reflect.ValueOf(elem)
inType := inValue.Type()
switch inType.Kind() {
case reflect.String:
return strings.Contains(inValue.String(), elemValue.String())
case reflect.Map:
equalTo := equal(elem, true)
for _, key := range inValue.MapKeys() {
if equalTo(key, inValue.MapIndex(key)) {
return true
}
}
case reflect.Slice, reflect.Array:
equalTo := equal(elem)
for i := 0; i < inValue.Len(); i++ {
if equalTo(reflect.Value{}, inValue.Index(i)) {
return true
}
}
default:
panic(fmt.Sprintf("Type %s is not supported by Contains, supported types are String, Map, Slice, Array", inType.String()))
}
return false
}
|
参考