反射

    Go是一门具有良好反射支持的静态语言。 本文将解释reflect标准库包中提供的反射功能。

    在阅读本剩下的部分之前，最好先阅读Go类型系统概述和两篇文章。

    从中，我们得知目前Go缺少自定义泛型支持。 Go中提供的反射功能带来了很多动态特性，从而从一定程度上弥补了Go缺少自定义泛型而导致的不便（尽管反射比泛型的运行效率低）。 很多标准库，比如fmt和很多encoding包，均十分依赖于反射机制。

    我们可以通过reflect库包中Type和Value两个类型提供的功能来观察不同的Go值。 本文下面的内容将介绍如何使用这两个类型。

    Go反射机制设计的目标之一是任何非反射操作都可以通过反射机制来完成。 由于各种各样的原因，此目标并没有得到100%的实现。 但是，目前大部分的非反射操作都可以通过反射机制来完成。 另一方面，通过反射，我们也可以完成一些使用非反射操作不可能完成的操作。 不能或者只能通过反射完成的操作将在下面的讲解中提及。

    通过调用reflect.TypeOf函数，我们可以从一个任何非接口类型的值创建一个reflect.Type值。 此reflect.Type值表示着此非接口值的类型。通过此值，我们可以得到很多此非接口类型的信息。 当然，我们也可以将一个接口值传递给一个reflect.TypeOf函数调用，但是此调用将返回一个表示着此接口值的动态类型的reflect.Type值。 实际上，reflect.TypeOf函数的唯一参数的类型为interface{}， reflect.TypeOf函数将总是返回一个表示着此唯一接口参数值的动态类型的reflect.Type值。 那如何得到一个表示着某个接口类型的reflect.Type值呢？ 我们必须通过下面将要介绍的一些间接途径来达到这一目的。

    类型reflect.Type为一个接口类型，它指定了。 通过这些方法，我们能够观察到一个reflect.Type值所表示的Go类型的各种信息。 这些方法中的有些适用于所有种类的类型，有些只适用于一种或几种类型。 通过不合适的reflect.Type属主值调用某个方法将在运行时产生一个恐慌。 请阅读reflect代码库中各个方法的文档来获取如何正确地使用这些方法。

    一个例子：

    目前，Go支持。

    在上面这个例子中，我们使用方法Elem来得到某些类型的元素类型。 实际上，此方法也可以用来得到一个指针类型的基类型。一个例子：

    1. package main
    3. import "fmt"
    4. import "reflect"
    6. type T []interface{m()}
    7. func (T) m() {}
    9. func main() {
    10.     tp := reflect.TypeOf(new(interface{}))
    11.     tt := reflect.TypeOf(T{})
    12.     fmt.Println(tp.Kind(), tt.Kind()) // ptr slice
    14.     // 使用间接的方法得到表示两个接口类型的reflect.Type值。
    15.     ti, tim := tp.Elem(), tt.Elem()
    16.     fmt.Println(ti.Kind(), tim.Kind()) // interface interface
    18.     fmt.Println(tt.Implements(tim))  // true
    19.     fmt.Println(tp.Implements(tim))  // false
    20.     fmt.Println(tim.Implements(tim)) // true
    22.     // 所有的类型都实现了任何空接口类型。
    23.     fmt.Println(tp.Implements(ti))  // true
    24.     fmt.Println(tt.Implements(ti))  // true
    25.     fmt.Println(tim.Implements(ti)) // true
    26.     fmt.Println(ti.Implements(ti))  // true
    27. }

    上面这个例子同时也展示了如何通过间接的途径得到一个表示一个接口类型的reflect.Type值。

    我们可以通过反射列出一个类型的所有方法和一个结构体类型的所有（导出和非导出）字段的类型。 我们也可以通过反射列出一个函数类型的各个输入参数和返回结果类型。

    1. package main
    3. import "fmt"
    4. import "reflect"
    6. type F func(string, int) bool
    7. func (f F) m(s string) bool {
    8.     return f(s, 32)
    9. }
    10. func (f F) M() {}
    12. type I interface{m(s string) bool; M()}
    14. func main() {
    15.     var x struct {
    16.         F F
    17.         i I
    18.     }
    19.     tx := reflect.TypeOf(x)
    20.     fmt.Println(tx.Kind())        // struct
    21.     fmt.Println(tx.NumField())    // 2
    22.     fmt.Println(tx.Field(1).Name) // i
    23.     // 包路径（PkgPath）是非导出字段（或者方法）的内在属性。
    24.     fmt.Println(tx.Field(0).PkgPath) // 
    25.     fmt.Println(tx.Field(1).PkgPath) // main
    27.     tf, ti := tx.Field(0).Type, tx.Field(1).Type
    28.     fmt.Println(tf.Kind())               // func
    29.     fmt.Println(tf.IsVariadic())         // false
    30.     fmt.Println(tf.NumIn(), tf.NumOut()) // 2 1
    31.     t0, t1, t2 := tf.In(0), tf.In(1), tf.Out(0)
    32.     // 下一行打印出：string int bool
    33.     fmt.Println(t0.Kind(), t1.Kind(), t2.Kind())
    35.     fmt.Println(tf.NumMethod(), ti.NumMethod()) // 1 2
    36.     fmt.Println(tf.Method(0).Name)              // M
    37.     fmt.Println(ti.Method(1).Name)              // m
    38.     _, ok1 := tf.MethodByName("m")
    39.     _, ok2 := ti.MethodByName("m")
    40.     fmt.Println(ok1, ok2) // false true
    41. }

    从上面这个例子我们可以看出：

    1. 对于非接口类型，reflect.Type.NumMethod方法只返回一个类型的所有导出的方法（包括通过内嵌得来的隐式方法）的个数，并且 方法reflect.Type.MethodByName不能用来获取一个类型的非导出方法； 而对于接口类型，则并无这些限制（Go 1.16之前的文档对这两个方法的描述不准确，并没有体现出这个差异）。 此情形同样存在于下一节将要介绍的reflect.Value类型上的相应方法。
    2. 虽然reflect.Type.NumField方法返回一个结构体类型的所有字段（包括非导出字段）的数目，但是不推荐使用方法reflect.Type.FieldByName来获取非导出字段。
    1. package main
    3. import "fmt"
    4. import "reflect"
    6. type T struct {
    7.     X    int  `max:"99" min:"0" default:"0"`
    8.     Y, Z bool `optional:"yes"`
    9. }
    11. func main() {
    12.     t := reflect.TypeOf(T{})
    13.     x := t.Field(0).Tag
    14.     y := t.Field(1).Tag
    15.     z := t.Field(2).Tag
    16.     fmt.Println(reflect.TypeOf(x)) // reflect.StructTag
    17.     // v的类型为string
    18.     v, present := x.Lookup("max")     
    19.     fmt.Println(len(v), present)      // 2 true
    20.     fmt.Println(x.Get("max"))         // 99
    21.     fmt.Println(x.Lookup("optional")) //  false
    22.     fmt.Println(y.Lookup("optional")) // yes true
    23.     fmt.Println(z.Lookup("optional")) // yes true
    24. }

    注意：

    • 键值对中的键不能包含空格（Unicode值为32）、双引号（Unicode值为34）和冒号（Unicode值为58）。
    • 为了形成键值对，所设想的键值对形式中的冒号的后面不能紧跟着空格字符。所以
      `optional: "yes"` 不形成键值对。
    • 键值对中的值中的空格不会被忽略。所以
      `json:"author, omitempty“` 、
      `json:" author,omitempty“` 以及
      `json:"author,omitempty“` 各不相同。
    • 每个字段标签应该呈现为单行才能使它的整个部分都对键值对的形成有贡献。

    reflect代码包也提供了一些其它函数来动态地创建出来一些非定义组合类型。

    1. package main
    3. import "fmt"
    4. import "reflect"
    5. func main() {
    6.     ta := reflect.ArrayOf(5, reflect.TypeOf(123))
    8.     tc := reflect.ChanOf(reflect.SendDir, ta)
    9.     fmt.Println(tc) // chan<- [5]int
    10.     tp := reflect.PtrTo(ta)
    11.     fmt.Println(tp) // *[5]int
    12.     ts := reflect.SliceOf(tp)
    13.     fmt.Println(ts) // []*[5]int
    14.     tm := reflect.MapOf(ta, tc)
    15.     fmt.Println(tm) // map[[5]int]chan<- [5]int
    16.     tf := reflect.FuncOf([]reflect.Type{ta},
    17.                 []reflect.Type{tp, tc}, false)
    18.     fmt.Println(tf) // func([5]int) (*[5]int, chan<- [5]int)
    19.     tt := reflect.StructOf([]reflect.StructField{
    20.         {Name: "Age", Type: reflect.TypeOf("abc")},
    21.     })
    22.     fmt.Println(tt)            // struct { Age string }
    23.     fmt.Println(tt.NumField()) // 1
    24. }

    上面的例子并未展示和reflect.Type相关的所有函数和方法。 请阅读reflect标准库代码包的文档以获取如何使用这些函数和方法。

    注意，到目前为止（Go 1.17），我们无法通过反射动态创建一个接口类型。这是Go反射目前的一个限制。

    另一个限制是使用反射动态创建结构体类型的时候可能会有各种不完美的情况出现。

    第三个限制是我们无法通过反射来声明一个新的类型。

    类似的，我们可以通过调用reflect.ValueOf函数，从一个非接口类型的值创建一个reflect.Value值。 此reflect.Value值代表着此非接口值。 和reflect.TypeOf函数类似，reflect.ValueOf函数也只有一个interface{}类型的参数。 当我们将一个接口值传递给一个reflect.ValueOf函数调用时，此调用返回的是代表着此接口值的动态值的一个reflect.Value值。 我们必须通过间接的途径获得一个代表一个接口值的reflect.Value值。

    被一个reflect.Value值代表着的值常称为此reflect.Value值的底层值（underlying value）。

    reflect.Value类型有很多方法。 我们可以调用这些方法来观察和操纵一个reflect.Value属主值表示的Go值。 这些方法中的有些适用于所有种类类型的值，有些只适用于一种或几种类型的值。 通过不合适的reflect.Value属主值调用某个方法将在运行时产生一个恐慌。 请阅读reflect代码库中各个方法的文档来获取如何正确地使用这些方法。

    一个reflect.Value值的CanSet方法将返回此reflect.Value值代表的Go值是否可以被修改（可以被赋值）。 如果一个Go值可以被修改，则我们可以调用对应的reflect.Value值的Set方法来修改此Go值。 注意：reflect.ValueOf函数直接返回的reflect.Value值都是不可修改的。

    一个例子：

    一个结构体值的非导出字段不能通过反射来修改。

    1. package main
    3. import "fmt"
    4. import "reflect"
    6. func main() {
    7.     var s struct {
    8.         X interface{} // 一个导出字段
    9.         y interface{} // 一个非导出字段
    10.     }
    11.     vp := reflect.ValueOf(&s)
    12.     // 如果vp代表着一个指针，下一行等价于"vs := vp.Elem()"。
    13.     vs := reflect.Indirect(vp)
    14.     // vx和vy都各自代表着一个接口值。
    15.     vx, vy := vs.Field(0), vs.Field(1)
    16.     fmt.Println(vx.CanSet(), vx.CanAddr()) // true true
    17.     // vy is addressable but not modifiable.
    18.     fmt.Println(vy.CanSet(), vy.CanAddr()) // false true
    19.     vb := reflect.ValueOf(123)
    20.     vx.Set(vb)     // okay, 因为vx代表的值是可修改的。
    21.     // vy.Set(vb)  // 会造成恐慌，因为vy代表的值是不可修改的。
    22.     fmt.Println(s) // {123 
    23.     fmt.Println(vx.IsNil(), vy.IsNil()) // false true
    24. }

    上例中同时也展示了如何间接地获取底层值为接口值的reflect.Value值。

    1. 通过调用代表着此指针值的reflect.Value值的Elem方法。
    2. 将代表着此指针值的reflect.Value值的传递给一个reflect.Indirect函数调用。 （如果传递给一个reflect.Indirect函数调用的实参不代表着一个指针值，则此调用返回此实参的一个复制。）

    注意：reflect.Value.Elem方法也可以用来获取一个代表着一个接口值的动态值的reflect.Value值，比如下例中所示。

    1. package main
    3. import "fmt"
    4. import "reflect"
    6. func main() {
    7.     var z = 123
    8.     var y = &z
    9.     var x interface{} = y
    10.     v := reflect.ValueOf(&x)
    11.     vx := v.Elem()
    12.     vy := vx.Elem()
    13.     vz := vy.Elem()
    14.     vz.Set(reflect.ValueOf(789))
    15.     fmt.Println(z) // 789
    16. }

    reflect标准库包中也提供了一些对应着内置函数或者各种非反射功能的函数。 下面这个例子展示了如何利用这些函数将一个自定义泛型函数绑定到不同的类型的函数值上。

    1. package main
    3. import "fmt"
    4. import "reflect"
    6. func InvertSlice(args []reflect.Value) []reflect.Value {
    7.     inSlice, n := args[0], args[0].Len()
    8.     outSlice := reflect.MakeSlice(inSlice.Type(), 0, n)
    9.     for i := n-1; i >= 0; i-- {
    10.         element := inSlice.Index(i)
    11.         outSlice = reflect.Append(outSlice, element)
    12.     }
    13.     return []reflect.Value{outSlice}
    14. }
    16. func Bind(p interface{}, 
    17.         f func ([]reflect.Value) []reflect.Value) {
    18.     // invert代表着一个函数值。
    19.     invert := reflect.ValueOf(p).Elem()
    20.     invert.Set(reflect.MakeFunc(invert.Type(), f))
    21. }
    23. func main() {
    24.     var invertInts func([]int) []int
    25.     Bind(&invertInts, InvertSlice)
    26.     fmt.Println(invertInts([]int{2, 3, 5})) // [5 3 2]
    28.     var invertStrs func([]string) []string
    29.     Bind(&invertStrs, InvertSlice)
    30.     fmt.Println(invertStrs([]string{"Go", "C"})) // [C Go]
    31. }

    如果一个reflect.Value值的底层值为一个函数值，则我们可以调用此reflect.Value值的Call方法来调用此函数。 每个Call方法调用接受一个[]reflect.Value类型的参数（表示传递给相应函数调用的各个实参）并返回一个同类型结果（表示相应函数调用返回的各个结果）。

    1. package main
    3. import "fmt"
    4. import "reflect"
    6. type T struct {
    7.     A, b int
    8. }
    10. func (t T) AddSubThenScale(n int) (int, int) {
    11.     return n * (t.A + t.b), n * (t.A - t.b)
    12. }
    13. func main() {
    14.     t := T{5, 2}
    15.     vt := reflect.ValueOf(t)
    16.     vm := vt.MethodByName("AddSubThenScale")
    17.     results := vm.Call([]reflect.Value{reflect.ValueOf(3)})
    18.     fmt.Println(results[0].Int(), results[1].Int()) // 21 9
    20.     neg := func(x int) int {
    21.         return -x
    22.     }
    23.     vf := reflect.ValueOf(neg)
    24.     fmt.Println(vf.Call(results[:1])[0].Int()) // -21
    25.     fmt.Println(vf.Call([]reflect.Value{
    26.         vt.FieldByName("A"), // 如果是字段b，则造成恐慌
    27.     })[0].Int()) // -5
    28. }

    请注意：非导出结构体字段值不能用做反射函数调用中的实参。 如果上例中的vt.FieldByName("A")被替换为vt.FieldByName("b")，则将产生一个恐慌。

    下面是一个使用映射反射值的例子。

    注意：方法reflect.Value.MapRange方法是从Go 1.12开始才支持的。

    下面是一个使用通道反射值的例子。

    1. package main
    3. import "fmt"
    4. import "reflect"
    6. func main() {
    7.     c := make(chan string, 2)
    8.     vc := reflect.ValueOf(c)
    9.     vc.Send(reflect.ValueOf("C"))
    10.     succeeded := vc.TrySend(reflect.ValueOf("Go"))
    11.     fmt.Println(succeeded) // true
    12.     succeeded = vc.TrySend(reflect.ValueOf("C++"))
    13.     fmt.Println(succeeded) // false
    14.     fmt.Println(vc.Len(), vc.Cap()) // 2 2
    15.     vs, succeeded := vc.TryRecv()
    16.     fmt.Println(vs.String(), succeeded) // C true
    17.     vs, sentBeforeClosed := vc.Recv()
    18.     fmt.Println(vs.String(), sentBeforeClosed) // Go false
    19.     vs, succeeded = vc.TryRecv()
    20.     fmt.Println(vs.String()) // 
    21.     fmt.Println(succeeded)   // false
    22. }

    reflect.Value类型的TrySend和TryRecv方法对应着只有一个case分支和一个default分支的。

    我们可以使用reflect.Select函数在运行时刻来模拟具有不定case分支数量的select流程控制代码块。

    1. package main
    3. import "fmt"
    4. import "reflect"
    6. func main() {
    7.     c := make(chan int, 1)
    8.     vc := reflect.ValueOf(c)
    9.     succeeded := vc.TrySend(reflect.ValueOf(123))
    10.     fmt.Println(succeeded, vc.Len(), vc.Cap()) // true 1 1
    12.     vSend, vZero := reflect.ValueOf(789), reflect.Value{}
    13.     branches := []reflect.SelectCase{
    14.         {Dir: reflect.SelectDefault, Chan: vZero, Send: vZero},
    15.         {Dir: reflect.SelectRecv, Chan: vc, Send: vZero},
    16.         {Dir: reflect.SelectSend, Chan: vc, Send: vSend},
    17.     }
    18.     selIndex, vRecv, sentBeforeClosed := reflect.Select(branches)
    19.     fmt.Println(selIndex)         // 1
    20.     fmt.Println(sentBeforeClosed) // true
    21.     fmt.Println(vRecv.Int())      // 123
    22.     vc.Close()
    23.     // 再模拟一次select流程控制代码块。因为vc已经关闭了，
    24.     // 所以需将最后一个case分支去除，否则它可能会造成一个恐慌。
    25.     selIndex, _, sentBeforeClosed = reflect.Select(branches[:2])
    26.     fmt.Println(selIndex, sentBeforeClosed) // 1 false
    27. }

    一些reflect.Value值可能表示着不合法的Go值。 这样的值为reflect.Value类型的零值（即没有底层值的reflect.Value值）。

    1. package main
    3. import "reflect"
    4. import "fmt"
    6. func main() {
    7.     var z reflect.Value // 一个reflect.Value零值
    8.     fmt.Println(z)      // 
    9.     v := reflect.ValueOf((*int)(nil)).Elem()
    10.     fmt.Println(v)      // 
    11.     fmt.Println(v == z) // true
    12.     var i = reflect.ValueOf([]interface{}{nil}).Index(0)
    13.     fmt.Println(i)             // 
    14.     fmt.Println(i.Elem())      // 
    15.     fmt.Println(i.Elem() == z) // true
    16. }

    从上面的例子中，我们知道，使用空接口interface{}值做为中介，一个Go值可以转换为一个reflect.Value值。 逆过程类似，通过调用一个reflect.Value值的Interface方法得到一个interface{}值，然后将此interface{}断言为原来的Go值。 但是，请注意，调用一个代表着非导出字段的reflect.Value值的Interface方法将导致一个恐慌。

    1. package main
    3. import (
    4.     "fmt"
    5.     "reflect"
    6.     "time"
    7. )
    9. func main() {
    10.     vx := reflect.ValueOf(123)
    11.     vy := reflect.ValueOf("abc")
    12.     vz := reflect.ValueOf([]bool{false, true})
    13.     vt := reflect.ValueOf(time.Time{})
    15.     x := vx.Interface().(int)
    16.     y := vy.Interface().(string)
    17.     z := vz.Interface().([]bool)
    18.     m := vt.MethodByName("IsZero").Interface().(func() bool)
    19.     fmt.Println(x, y, z, m()) // 123 abc [false true] true
    21.     type T struct {x int}
    22.     t := &T{3}
    23.     v := reflect.ValueOf(t).Elem().Field(0)
    24.     fmt.Println(v)             // 3
    25. }

    Value.IsZero方法是Go 1.13中引进的，此方法用来查看一个值是否为零值。

    从Go 1.17开始，一个切片可以被转化为一个相同元素类型的数组的指针类型。 但是如果在这样的一个转换中数组类型的长度过长，将导致恐慌产生。 因此Go 1.17同时引入了一个Value.CanConvert(T Type)方法，用来检查一个转换是否会成功（即不会产生恐慌）。

    上面这些例子并未触及到所有的和相关的函数和方法，请阅读reflect标准库包的文档以获取如何使用这些函数和方法。 另外请注意中提到的一些关于。