Golang 反射
原文作者：OhBonsai 来源：简书
基本了解
在Go语言中，大多数时候值/类型/函数非常直接，要的话，定义一个。你想要个Struct
1type Foo struct {
2 A int
3 B string
4}你想要一个值，你定义出来
1var x Foo你想要一个函数，你定义出来
1func DoSomething(f Foo) {
2 fmt.Println(f.A, f.B)
3}但是有些时候，你需要搞一些运行时才能确定的东西，比如你要从文件或者网络中获取一些字典数据。又或者你要搞一些不同类型的数据。在这种情况下，reflection就有用啦。reflection能够让你拥有以下能力
- 在运行时检查type
- 在运行时检查/修改/创建 值/函数/结构
总的来说，go的
reflection围绕者三个概念Types,Kinds,Values。 所有关于反射的操作都在reflect包里面
反射的Power
Type的Power
首先，我们看看如何通过反射来获取值得类型。
1varType := reflect.TypeOf(var)从反射接口可以看到有一大堆得函数等着我们去用。可以从注释里面看到。反射包默认我们知道我们要干啥子，比如varType.Elem()就会panic。因为Elem()只有Array, Chan, Map, Ptr, or Slice.这些类型才有这个方法。具体可以查看测试代码。通过运行以下代码可查看所有reflect函数的示例
1package main
2
3import (
4 "fmt"
5 "reflect"
6)
7
8type FooIF interface {
9 DoSomething()
10 DoSomethingWithArg(a string)
11 DoSomethingWithUnCertenArg(a ... string)
12}
13
14type Foo struct {
15 A int
16 B string
17 C struct {
18 C1 int
19 }
20}
21
22func (f *Foo) DoSomething() {
23 fmt.Println(f.A, f.B)
24}
25
26func (f *Foo) DoSomethingWithArg(a string) {
27 fmt.Println(f.A, f.B, a)
28}
29
30func (f *Foo) DoSomethingWithUnCertenArg(a ... string) {
31 fmt.Println(f.A, f.B, a[0])
32}
33
34func (f *Foo) returnOneResult() int {
35 return 2
36}
37
38func main() {
39 var simpleObj Foo
40 var pointer2obj = &simpleObj
41 var simpleIntArray = [3]int{1, 2, 3}
42 var simpleMap = map[string]string{
43 "a": "b",
44 }
45 var simpleChan = make(chan int, 1)
46 var x uint64
47 var y uint32
48
49 varType := reflect.TypeOf(simpleObj)
50 varPointerType := reflect.TypeOf(pointer2obj)
51
52 // 对齐之后要多少容量
53 fmt.Println("Align: ", varType.Align())
54 // 作为结构体的`field`要对其之后要多少容量
55 fmt.Println("FieldAlign: ", varType.FieldAlign())
56 // 叫啥
57 fmt.Println("Name: ", varType.Name())
58 // 绝对引入路径
59 fmt.Println("PkgPath: ", varType.PkgPath())
60 // 实际上用了多少内存
61 fmt.Println("Size: ", varType.Size())
62 // 到底啥类型的
63 fmt.Println("Kind: ", varType.Kind())
64
65 // 有多少函数
66 fmt.Println("NumMethod: ", varPointerType.NumMethod())
67
68 // 通过名字获取一个函数
69 m, success := varPointerType.MethodByName("DoSomethingWithArg")
70 if success {
71 m.Func.Call([]reflect.Value{
72 reflect.ValueOf(pointer2obj),
73 reflect.ValueOf("sad"),
74 })
75 }
76
77 // 通过索引获取函数
78 m = varPointerType.Method(1)
79 m.Func.Call([]reflect.Value{
80 reflect.ValueOf(pointer2obj),
81 reflect.ValueOf("sad2"),
82 })
83
84 // 是否实现了某个接口
85 fmt.Println("Implements:", varPointerType.Implements(reflect.TypeOf((*FooIF)(nil)).Elem()))
86
87 // 看看指针多少bit
88 fmt.Println("Bits: ", reflect.TypeOf(x).Bits())
89
90 // 查看array, chan, map, ptr, slice的元素类型
91 fmt.Println("Elem: ", reflect.TypeOf(simpleIntArray).Elem().Kind())
92
93 // 查看Array长度
94 fmt.Println("Len: ", reflect.TypeOf(simpleIntArray).Len())
95
96 // 查看结构体field
97 fmt.Println("Field", varType.Field(1))
98
99 // 查看结构体field
100 fmt.Println("FieldByIndex", varType.FieldByIndex([]int{2, 0}))
101
102 // 查看结构提field
103 fi, success2 := varType.FieldByName("A")
104 if success2 {
105 fmt.Println("FieldByName", fi)
106 }
107
108 // 查看结构体field
109 fi, success2 = varType.FieldByNameFunc(func(fieldName string) bool {
110 return fieldName == "A"
111 })
112 if success2 {
113 fmt.Println("FieldByName", fi)
114 }
115
116 // 查看结构体数量
117 fmt.Println("NumField", varType.NumField())
118
119 // 查看map的key类型
120 fmt.Println("Key: ", reflect.TypeOf(simpleMap).Key().Name())
121
122 // 查看函数有多少个参数
123 fmt.Println("NumIn: ", reflect.TypeOf(pointer2obj.DoSomethingWithUnCertenArg).NumIn())
124
125 // 查看函数参数的类型
126 fmt.Println("In: ", reflect.TypeOf(pointer2obj.DoSomethingWithUnCertenArg).In(0))
127
128 // 查看最后一个参数，是否解构了
129 fmt.Println("IsVariadic: ", reflect.TypeOf(pointer2obj.DoSomethingWithUnCertenArg).IsVariadic())
130
131 // 查看函数有多少输出
132 fmt.Println("NumOut: ", reflect.TypeOf(pointer2obj.DoSomethingWithUnCertenArg).NumOut())
133
134 // 查看函数输出的类型
135 fmt.Println("Out: ", reflect.TypeOf(pointer2obj.returnOneResult).Out(0))
136
137 // 查看通道的方向, 3双向。
138 fmt.Println("ChanDir: ", int(reflect.TypeOf(simpleChan).ChanDir()))
139
140 // 查看该类型是否可以比较。不能比较的slice, map, func
141 fmt.Println("Comparable: ", varPointerType.Comparable())
142
143 // 查看类型是否可以转化成另外一种类型
144 fmt.Println("ConvertibleTo: ", varPointerType.ConvertibleTo(reflect.TypeOf("a")))
145
146 // 该类型的值是否可以另外一个类型
147 fmt.Println("AssignableTo: ", reflect.TypeOf(x).AssignableTo(reflect.TypeOf(y)))
148}Value的Power
除了检查变量的类型，你可以通过reflection来读/写/新建一个值。不过首先先获取反射值类型
1refVal := reflect.ValueOf(var) 如果你想要修改变量的值。你需要获取反射指向该变量的指针，具体原因后面解释
1refPtrVal := reflect.ValueOf(&var)当然你有了reflect.Value,通过Type()方法可以很容易的获取reflect.Type。如果要改变该变量的值用
1refPtrVal.Elem().Set(newRefValue)当然Set方法的参数必须也得是reflect.Value
如果你想创建一个新的值，用以下下代码
1newPtrVal := reflect.New(varType)然后在用Elem().Set()来进行值的初始化。当然还有不同的value有一大堆的不同的方法。这里就不写了。我们重点看看下面这段官方例子
1package main
2
3import (
4 "fmt"
5 "reflect"
6)
7
8func main() {
9 // swap is the implementation passed to MakeFunc.
10 // It must work in terms of reflect.Values so that it is possible
11 // to write code without knowing beforehand what the types
12 // will be.
13 swap := func(in []reflect.Value) []reflect.Value {
14 return []reflect.Value{in[1], in[0]}
15 }
16
17 // makeSwap expects fptr to be a pointer to a nil function.
18 // It sets that pointer to a new function created with MakeFunc.
19 // When the function is invoked, reflect turns the arguments
20 // into Values, calls swap, and then turns swap's result slice
21 // into the values returned by the new function.
22 makeSwap := func(fptr interface{}) {
23 // fptr is a pointer to a function.
24 // Obtain the function value itself (likely nil) as a reflect.Value
25 // so that we can query its type and then set the value.
26 fn := reflect.ValueOf(fptr).Elem()
27
28 // Make a function of the right type.
29 v := reflect.MakeFunc(fn.Type(), swap)
30
31 // Assign it to the value fn represents.
32 fn.Set(v)
33 }
34
35 // Make and call a swap function for ints.
36 var intSwap func(int, int) (int, int)
37 makeSwap(&intSwap)
38 fmt.Println(intSwap(0, 1))
39
40 // Make and call a swap function for float64s.
41 var floatSwap func(float64, float64) (float64, float64)
42 makeSwap(&floatSwap)
43 fmt.Println(floatSwap(2.72, 3.14))
44
45}
46原理
认清楚type与interface
go是一个静态类型语言，每一个变量有static type，比如int，float，何谓static type，我的理解是一定长度的二进制块与解释。比如同样的二进制块00000001 在bool类型中意思是true。而在int类型中解释是1. 我们看看以下这个最简单的例子
1type MyInt int
2var i int
3var j MyInti,j在内存中都是用int这一个底层类型来表示，但是在实际编码过程中，在编译的时候他们并非一个类型，你不能直接将i的值赋给j。是不是有点奇怪，你执行的时候编译器会告诉你，你不能将MyInt类型的值赋给int类型的值。这个type不是class也不是python的type.
interface作为一种特殊的type, 表示方法的集合。一个interface的值可以存任何确定的值只要这个值实现了interface的方法。interface{}某些时候和Java的Object好想，实际上interface是有两部分内容组成的，实际的值和值的具体类型。这也可以解释为什么下面这段代码和其他语言都不一样。具体关于interface的原理可以参考go data structures: interfaces。
1package main
2
3import (
4 "fmt"
5)
6
7type A interface {
8 x(param int)
9}
10
11type B interface {
12 y(param int)
13}
14
15
16type AB struct {
17
18}
19
20func (ab *AB) x(param int) {
21 fmt.Printf("%p", ab)
22 fmt.Println(param)
23}
24
25func (ab *AB) y(param int) {
26 fmt.Printf("%p", ab)
27 fmt.Println(param)
28}
29
30
31func printX(a A){
32 fmt.Printf("%p", a)
33 a.x(2)
34}
35
36func printY(b B){
37 fmt.Printf("%p", b)
38 b.y(3)
39}
40
41
42
43func main() {
44 var ab = new(AB)
45 printX(ab)
46 printY(ab)
47
48
49 var aInfImpl A
50 var bInfImpl B
51
52 aInfImpl = new(AB)
53 //bInfImpl = aInfImpl 会报错
54 bInfImpl = aInfImpl.(B)
55 bInfImpl.y(2)
56}golang反射三定理
把一个interface值，拆分出反射对象
反射仅仅用于检查接口值的(Value, Type)。如上一章提到的两个方法ValueOf和TypeOf。通过ValueOf我门可以轻易的拿到Type
1package main
2
3import (
4 "fmt"
5 "reflect"
6)
7
8func main() {
9 var x float64 = 3.4
10 fmt.Println("type:", reflect.TypeOf(x))
11}这段代码输出
1type: float64那么问题就来了，接口在哪里？只是申明了一个float64的变量。哪里来的interface。有的，答案就藏在 TypeOf参数里面
1func TypeOf(i interface{}) Type当我们调用reflect.TypeOf(x), x首先被存在一个空的interface里面。然后在被当作参数传到函数执行栈内。** reflect.TypeOf解开这个interface的pair然后恢复出类型信息**
把反射对象组合成一个接口值
就像镜面反射一样，go的反射是可逆的。给我一个reflect.Value。我们能够恢复出一个interface的值。事实上，以下函数干的事情就是将Value和Type组狠起来塞到 interface里面去。所以我们可以
1y := v.Interface().(float64) // y will have type float64.
2fmt.Println(y)接下来就是见证奇迹的时刻。fmt.Println和fmt.Printf的参数都是interface{}。我们真正都不需要将上面例子的y转化成明确的float64。我就可以去打印他比如
1fmt.Println(v.Interface())甚至我们的interface藏着的那个type是float64。我们可以直接用占位符来打印
1fmt.Println("Value is %7.le\n", v.Interface())再重复一边，没有必要将v.Interface()的类型强转到float64;这个空的interface{}包含了concrete type。函数调用会恢复出来
要改变一个反射对象，其值必须是可设置的
第三条比较让你比较困惑。不过如果我们理解了第一条，那么这条其实非常好理解。先看一下下面这个例子
1var x float64 = 3.4
2v := reflect.ValueOf(x)
3v.SetFloat(7.1) // Error: will panic.如果执行这段代码，你会发现出现panic以下信息
1panic: reflect.Value.SetFloat using unaddressable value可设置性是一个好东西，但不是所有reflect.Value都有他...可以通过CanSet 函数来获取是否可设置
1var x float64 = 3.4
2v := reflect.ValueOf(x)
3fmt.Println("settability of v:", v.CanSet())那么到底为什么要有一个可设置性呢？可寻址才可设置，我们在用reflect.ValueOf时候，实际上是函数传值。获取x的反射对象，实际上是另外一个float64的内存的反射对象。这个时候我们再去设置该反射对象的值，没有意义。这段内存并不是你申明的那个x。
资料 golang doc learning-to-use-go-reflection law of reflection
版权申明：内容来源网络，版权归原创者所有。除非无法确认，我们都会标明作者及出处，如有侵权烦请告知，我们会立即删除并表示歉意。谢谢。
腾讯云开发者
