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,比如intfloat,何谓static type,我的理解是一定长度的二进制块与解释。比如同样的二进制块00000001 在bool类型中意思是true。而在int类型中解释是1. 我们看看以下这个最简单的例子

1type MyInt int
2var i int
3var j MyInt

i,j在内存中都是用int这一个底层类型来表示,但是在实际编码过程中,在编译的时候他们并非一个类型,你不能直接将i的值赋给j。是不是有点奇怪,你执行的时候编译器会告诉你,你不能将MyInt类型的值赋给int类型的值。这个type不是class也不是pythontype.

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)。如上一章提到的两个方法ValueOfTypeOf。通过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解开这个interfacepair然后恢复出类型信息**

把反射对象组合成一个接口值

就像镜面反射一样,go的反射是可逆的。给我一个reflect.Value。我们能够恢复出一个interface的值。事实上,以下函数干的事情就是将ValueType组狠起来塞到 interface里面去。所以我们可以

1y := v.Interface().(float64) // y will have type float64.
2fmt.Println(y)

接下来就是见证奇迹的时刻。fmt.Printlnfmt.Printf的参数都是interface{}。我们真正都不需要将上面例子的y转化成明确的float64。我就可以去打印他比如

1fmt.Println(v.Interface())

甚至我们的interface藏着的那个typefloat64。我们可以直接用占位符来打印

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


版权申明:内容来源网络,版权归原创者所有。除非无法确认,我们都会标明作者及出处,如有侵权烦请告知,我们会立即删除并表示歉意。谢谢。

本文分享自微信公众号 - Golang语言社区(Golangweb)

原文出处及转载信息见文内详细说明,如有侵权,请联系 yunjia_community@tencent.com 删除。

原始发表时间:2019-02-14

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • Go Reflect 理解

    最近在看一些go语言标准库以及第三方库的源码时,发现go的reflect被大量使用,虽然反射的机制大多数语言都支持,但好像都没有go一样这么依赖反射的特性。个人...

    李海彬
  • golang 使用时间通过md5生成token

    package main import ( "crypto/md5" "fmt" "io" "strco...

    李海彬
  • Go语言获取Windows下文件是否隐藏

    package main import(   "fmt"   "io/ioutil"   "os" ) var dirpath ="D:\\" func mai...

    李海彬
  • Go基础之--反射

    反射:可以在运行时动态获取变量的相关信息 反射需要导入reflect 反射中重要函数的演示 反射有几下几个重要的函数: reflect.TypeOf :获取变量...

    coders
  • 反射的用法

    在学习反射时,所有人首先面临的疑惑就是:如果程序中每个变量都是我们自己定义的,那么在编译时就可以知道变量类型了,为什么我们还需要在运行时检查变量,求出它的类型呢

    酷走天涯
  • 反射

    在学习反射时,所有人首先面临的疑惑就是:如果程序中每个变量都是我们自己定义的,那么在编译时就可以知道变量类型了,为什么我们还需要在运行时检查变量,求出它的类型呢

    酷走天涯
  • Go语言(十五) 反射

    alexhuiwang
  • iOS面试中被面试官问到的问题

    问题如下: 请你谈谈static和宏定义的区别。什么时候用static什么时候用宏定义。 你是怎么看代理和通知的 他们有什么区别? 说说你对内存管理的理解。 谈...

    timhbw
  • IntelliJ IDEA 重大更新:支持 CPU 火焰图,新增酷炫主题

    就在上周,JetBrain 公司发布了 Java 集成开发环境 IntelliJ IDEA 最新版本 2018.3Beta,本篇文章,我将根据官方博客以及自己的...

    芋道源码
  • 闪电侠:2018.3 IntelliJ IDEA 重大更新:支持CPU火焰图,新增酷炫主题

    就在上周,JetBrain 公司发布了 Java 集成开发环境 IntelliJ IDEA 最新版本 2018.3Beta,本篇文章,我将根据官方博客以及自己的...

    java进阶架构师

扫码关注云+社区

领取腾讯云代金券