反射

反射

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

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

反射概述

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

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

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

`reflect.Type`类型和值

通过调用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代码库中各个方法的文档来获取如何正确地使用这些方法。

一个例子：

package main
import "fmt"
import "reflect"
func main() {
    type A = [16]int16
    var c <-chan map[A][]byte
    tc := reflect.TypeOf(c)
    fmt.Println(tc.Kind())    // chan
    fmt.Println(tc.ChanDir()) // <-chan
    tm := tc.Elem()
    ta, tb := tm.Key(), tm.Elem()
    fmt.Println(tm.Kind(), ta.Kind(), tb.Kind()) // map array slice
    tx, ty := ta.Elem(), tb.Elem()
    // byte是uint8类型的别名。
    fmt.Println(tx.Kind(), ty.Kind()) // int16 uint8
    fmt.Println(tx.Bits(), ty.Bits()) // 16 8
    fmt.Println(tx.ConvertibleTo(ty)) // true
    fmt.Println(tb.ConvertibleTo(ta)) // false
    // 切片类型和映射类型都是不可比较类型。
    fmt.Println(tb.Comparable()) // false
    fmt.Println(tm.Comparable()) // false
    fmt.Println(ta.Comparable()) // true
    fmt.Println(tc.Comparable()) // true
}

目前，Go支持26种种类的类型。

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

package main
import "fmt"
import "reflect"
type T []interface{m()}
func (T) m() {}
func main() {
    tp := reflect.TypeOf(new(interface{}))
    tt := reflect.TypeOf(T{})
    fmt.Println(tp.Kind(), tt.Kind()) // ptr slice
    // 使用间接的方法得到表示两个接口类型的reflect.Type值。
    ti, tim := tp.Elem(), tt.Elem()
    fmt.Println(ti.Kind(), tim.Kind()) // interface interface
    fmt.Println(tt.Implements(tim))  // true
    fmt.Println(tp.Implements(tim))  // false
    fmt.Println(tim.Implements(tim)) // true
    // 所有的类型都实现了任何空接口类型。
    fmt.Println(tp.Implements(ti))  // true
    fmt.Println(tt.Implements(ti))  // true
    fmt.Println(tim.Implements(ti)) // true
    fmt.Println(ti.Implements(ti))  // true
}

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

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

package main
import "fmt"
import "reflect"
type F func(string, int) bool
func (f F) m(s string) bool {
    return f(s, 32)
}
func (f F) M() {}
type I interface{m(s string) bool; M()}
func main() {
    var x struct {
        F F
        i I
    }
    tx := reflect.TypeOf(x)
    fmt.Println(tx.Kind())        // struct
    fmt.Println(tx.NumField())    // 2
    fmt.Println(tx.Field(1).Name) // i
    // 包路径（PkgPath）是非导出字段（或者方法）的内在属性。
    fmt.Println(tx.Field(0).PkgPath) // 
    fmt.Println(tx.Field(1).PkgPath) // main
    tf, ti := tx.Field(0).Type, tx.Field(1).Type
    fmt.Println(tf.Kind())               // func
    fmt.Println(tf.IsVariadic())         // false
    fmt.Println(tf.NumIn(), tf.NumOut()) // 2 1
    t0, t1, t2 := tf.In(0), tf.In(1), tf.Out(0)
    // 下一行打印出：string int bool
    fmt.Println(t0.Kind(), t1.Kind(), t2.Kind())
    fmt.Println(tf.NumMethod(), ti.NumMethod()) // 1 2
    fmt.Println(tf.Method(0).Name)              // M
    fmt.Println(ti.Method(1).Name)              // m
    _, ok1 := tf.MethodByName("m")
    _, ok2 := ti.MethodByName("m")
    fmt.Println(ok1, ok2) // false true
}

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

对于非接口类型，reflect.Type.NumMethod方法只返回一个类型的所有导出的方法（包括通过内嵌得来的隐式方法）的个数，并且方法reflect.Type.MethodByName不能用来获取一个类型的非导出方法；而对于接口类型，则并无这些限制（Go 1.16之前的文档对这两个方法的描述不准确，并没有体现出这个差异）。此情形同样存在于下一节将要介绍的reflect.Value类型上的相应方法。
虽然reflect.Type.NumField方法返回一个结构体类型的所有字段（包括非导出字段）的数目，但是不推荐使用方法reflect.Type.FieldByName来获取非导出字段。

我们可以通过反射来检视结构体字段的标签信息。结构体字段标签的类型为reflect.StructTag，它有两个方法：Get和Lookup。一个例子：

package main
import "fmt"
import "reflect"
type T struct {
    X int  `max:"99" min:"0"`
    Y bool `optional:"yes"`
}
func main() {
    t := reflect.TypeOf(T{})
    x, y := t.Field(0).Tag, t.Field(1).Tag
    fmt.Println(reflect.TypeOf(x)) // reflect.StructTag
    tag, present := y.Lookup("default")
    fmt.Println(len(tag), present)    // 0 false
    fmt.Println(y.Lookup("optional")) // yes true
    fmt.Println(x.Get("max"), x.Get("min")) // 99 0
}

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

package main
import "fmt"
import "reflect"
func main() {
    ta := reflect.ArrayOf(5, reflect.TypeOf(123))
    fmt.Println(ta) // [5]int
    tc := reflect.ChanOf(reflect.SendDir, ta)
    fmt.Println(tc) // chan<- [5]int
    tp := reflect.PtrTo(ta)
    fmt.Println(tp) // *[5]int
    ts := reflect.SliceOf(tp)
    fmt.Println(ts) // []*[5]int
    tm := reflect.MapOf(ta, tc)
    fmt.Println(tm) // map[[5]int]chan<- [5]int
    tf := reflect.FuncOf([]reflect.Type{ta},
                []reflect.Type{tp, tc}, false)
    fmt.Println(tf) // func([5]int) (*[5]int, chan<- [5]int)
    tt := reflect.StructOf([]reflect.StructField{
        {Name: "Age", Type: reflect.TypeOf("abc")},
    })
    fmt.Println(tt)            // struct { Age string }
    fmt.Println(tt.NumField()) // 1
}

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

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

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

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

`reflect.Value`类型和值

类似的，我们可以通过调用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值都是不可修改的。

一个例子：

package main
import "fmt"
import "reflect"
func main() {
    n := 123
    p := &n
    vp := reflect.ValueOf(p)
    fmt.Println(vp.CanSet(), vp.CanAddr()) // false false
    vn := vp.Elem() // 取得vp的底层指针值引用的值的代表值
    fmt.Println(vn.CanSet(), vn.CanAddr()) // true true
    vn.Set(reflect.ValueOf(789)) // <=> vn.SetInt(789)
    fmt.Println(n)               // 789
}

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

package main
import "fmt"
import "reflect"
func main() {
    var s struct {
        X interface{} // 一个导出字段
        y interface{} // 一个非导出字段
    }
    vp := reflect.ValueOf(&s)
    // 如果vp代表着一个指针，下一行等价于"vs := vp.Elem()"。
    vs := reflect.Indirect(vp)
    // vx和vy都各自代表着一个接口值。
    vx, vy := vs.Field(0), vs.Field(1)
    fmt.Println(vx.CanSet(), vx.CanAddr()) // true true
    // vy is addressable but not modifiable.
    fmt.Println(vy.CanSet(), vy.CanAddr()) // false true
    vb := reflect.ValueOf(123)
    vx.Set(vb)     // okay, 因为vx代表的值是可修改的。
    // vy.Set(vb)  // 会造成恐慌，因为vy代表的值是不可修改的。
    fmt.Println(s) // {123 <nil>}
    fmt.Println(vx.IsNil(), vy.IsNil()) // false true
}

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

从上两例中，我们可以得知有两种方法获取一个代表着一个指针所引用着的值的reflect.Value值：

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

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

package main
import "fmt"
import "reflect"
func main() {
    var z = 123
    var y = &z
    var x interface{} = y
    v := reflect.ValueOf(&x)
    vx := v.Elem()
    vy := vx.Elem()
    vz := vy.Elem()
    vz.Set(reflect.ValueOf(789))
    fmt.Println(z) // 789
}

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

package main
import "fmt"
import "reflect"
func InvertSlice(args []reflect.Value) (result []reflect.Value) {
    inSlice, n := args[0], args[0].Len()
    outSlice := reflect.MakeSlice(inSlice.Type(), 0, n)
    for i := n-1; i >= 0; i-- {
        element := inSlice.Index(i)
        outSlice = reflect.Append(outSlice, element)
    }
    return []reflect.Value{outSlice}
}
func Bind(p interface{}, f func ([]reflect.Value) []reflect.Value) {
    // invert代表着一个函数值。
    invert := reflect.ValueOf(p).Elem()
    invert.Set(reflect.MakeFunc(invert.Type(), f))
}
func main() {
    var invertInts func([]int) []int
    Bind(&invertInts, InvertSlice)
    fmt.Println(invertInts([]int{2, 3, 5})) // [5 3 2]
    var invertStrs func([]string) []string
    Bind(&invertStrs, InvertSlice)
    fmt.Println(invertStrs([]string{"Go", "C"})) // [C Go]
}

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

package main
import "fmt"
import "reflect"
type T struct {
    A, b int
}
func (t T) AddSubThenScale(n int) (int, int) {
    return n * (t.A + t.b), n * (t.A - t.b)
}
func main() {
    t := T{5, 2}
    vt := reflect.ValueOf(t)
    vm := vt.MethodByName("AddSubThenScale")
    results := vm.Call([]reflect.Value{reflect.ValueOf(3)})
    fmt.Println(results[0].Int(), results[1].Int()) // 21 9
    neg := func(x int) int {
        return -x
    }
    vf := reflect.ValueOf(neg)
    fmt.Println(vf.Call(results[:1])[0].Int()) // -21
    fmt.Println(vf.Call([]reflect.Value{
        vt.FieldByName("A"), // 如果是字段b，则造成恐慌
    })[0].Int()) // -5
}

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

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

package main
import "fmt"
import "reflect"
func main() {
    vakueOf := reflect.ValueOf
    m := map[string]int{"Unix": 1973, "Windows": 1985}
    v := vakueOf(m)
    // 第二个实参为Value零值时，表示删除一个映射条目。
    v.SetMapIndex(vakueOf("Windows"), reflect.Value{})
    v.SetMapIndex(vakueOf("Linux"), vakueOf(1991))
    for i := v.MapRange(); i.Next(); {
        fmt.Println(i.Key(), "\t:", i.Value())
    }
}

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

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

package main
import "fmt"
import "reflect"
func main() {
    c := make(chan string, 2)
    vc := reflect.ValueOf(c)
    vc.Send(reflect.ValueOf("C"))
    succeeded := vc.TrySend(reflect.ValueOf("Go"))
    fmt.Println(succeeded) // true
    succeeded = vc.TrySend(reflect.ValueOf("C++"))
    fmt.Println(succeeded) // false
    fmt.Println(vc.Len(), vc.Cap()) // 2 2
    vs, succeeded := vc.TryRecv()
    fmt.Println(vs.String(), succeeded) // C true
    vs, sentBeforeClosed := vc.Recv()
    fmt.Println(vs.String(), sentBeforeClosed) // Go false
    vs, succeeded = vc.TryRecv()
    fmt.Println(vs.String()) // <invalid Value>
    fmt.Println(succeeded)   // false
}

reflect.Value类型的TrySend和TryRecv方法对应着只有一个case分支和一个default分支的select流程控制代码块。

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

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

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

package main
import "reflect"
import "fmt"
func main() {
    var z reflect.Value // 一个reflect.Value零值
    fmt.Println(z)      // <invalid reflect.Value>
    v := reflect.ValueOf((*int)(nil)).Elem()
    fmt.Println(v)      // <invalid reflect.Value>
    fmt.Println(v == z) // true
    var i = reflect.ValueOf([]interface{}{nil}).Index(0)
    fmt.Println(i)             // <nil>
    fmt.Println(i.Elem())      // <invalid reflect.Value>
    fmt.Println(i.Elem() == z) // true
}

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

package main
import (
    "fmt"
    "reflect"
    "time"
)
func main() {
    vx := reflect.ValueOf(123)
    vy := reflect.ValueOf("abc")
    vz := reflect.ValueOf([]bool{false, true})
    vt := reflect.ValueOf(time.Time{})
    x := vx.Interface().(int)
    y := vy.Interface().(string)
    z := vz.Interface().([]bool)
    m := vt.MethodByName("IsZero").Interface().(func() bool)
    fmt.Println(x, y, z, m()) // 123 abc [false true] true
    type T struct {x int}
    t := &T{3}
    v := reflect.ValueOf(t).Elem().Field(0)
    fmt.Println(v)             // 3
    fmt.Println(v.Interface()) // panic
}

从Go 1.13开始，我们可以使用Value.IsZero方法来查看一个值是否为零值。

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

反射

反射

反射概述

reflect.Type类型和值

reflect.Value类型和值

`reflect.Type`类型和值

`reflect.Value`类型和值