为了账号安全，请及时绑定邮箱和手机立即绑定
首页 手记 深度解密Go语言之反射

深度解密Go语言之反射

标签：
Go

很多同学在后台向我反映文章太长了，不利于阅读，建议拆分一下。我非常理解，读屏时代，大家需要快速地读完全文，拿到收益。而码农桃花源的文章都非常长，读者很难在短时间内读完，并且获得相应的收益。

首先非常感谢大家的建议！其实我的想法是这样的：大家都在说，现在是一个信息严重过载的时代，信息多得看不完，不免产生很多焦虑。但是，我想说，优质的信息真有那么多吗？在我看来，文章的水平都是参差不齐，很多毫无内容和价值，大家把时间浪费在这些信息上面是很不值得的。因为你读了这些文章，就没有了读其他好的文章的精力。

所以，码农桃花源想做一个优质信息源，提供优质的内容。每一篇文章都是有深度，有内容，有收获。一篇文章，我一般得花费 2 周左右，算是半月更，和那些日更的没法比。当然，只是在数量上没法比。而这个时代，最不缺的就是数量。

另外，文章长也算是我的一个特色。我完全可以拆分成上、中、下等等，但我希望一次性交付给我的读者所有有价值的内容。这样，你可以集中一个小时或是更长时间，精读完一篇文章。

微信公众号阅读文章有时不是太方便，这里推荐大家用微信读书，直接搜索公众号名字就可以看到公众号所有的文章了，很方便。这个功能出来很久了，我也是不久前才知道，推荐给大家。

闲话结束，今天要讲的内容是反射，进入正题。

什么是反射

直接看维基百科上的定义：

在计算机科学中，反射是指计算机程序在运行时（Run time）可以访问、检测和修改它本身状态或行为的一种能力。用比喻来说，反射就是程序在运行的时候能够“观察”并且修改自己的行为。

那我就要问个问题了：不用反射就不能在运行时访问、检测和修改它本身的状态和行为吗？

问题的回答，其实要首先理解什么叫访问、检测和修改它本身状态或行为，它的本质是什么？

实际上，它的本质是程序在运行期探知对象的类型信息和内存结构，不用反射能行吗？可以的！使用汇编语言，直接和内层打交道，什么信息不能获取？但是，当编程迁移到高级语言上来之后，就不行了！就只能通过 反射来达到此项技能。

不同语言的反射模型不尽相同，有些语言还不支持反射。《Go 语言圣经》中是这样定义反射的：

Go 语言提供了一种机制在运行时更新变量和检查它们的值、调用它们的方法，但是在编译时并不知道这些变量的具体类型，这称为反射机制。

为什么要用反射

需要反射的 2 个常见场景：

  1. 有时你需要编写一个函数，但是并不知道传给你的参数类型是什么，可能是没约定好；也可能是传入的类型很多，这些类型并不能统一表示。这时反射就会用的上了。

  2. 有时候需要根据某些条件决定调用哪个函数，比如根据用户的输入来决定。这时就需要对函数和函数的参数进行反射，在运行期间动态地执行函数。

在讲反射的原理以及如何用之前，还是说几点不使用反射的理由：

  1. 与反射相关的代码，经常是难以阅读的。在软件工程中，代码可读性也是一个非常重要的指标。

  2. Go 语言作为一门静态语言，编码过程中，编译器能提前发现一些类型错误，但是对于反射代码是无能为力的。所以包含反射相关的代码，很可能会运行很久，才会出错，这时候经常是直接 panic，可能会造成严重的后果。

  3. 反射对性能影响还是比较大的，比正常代码运行速度慢一到两个数量级。所以，对于一个项目中处于运行效率关键位置的代码，尽量避免使用反射特性。

反射是如何实现的

上一篇文章讲到了 interface，它是 Go 语言实现抽象的一个非常强大的工具。当向接口变量赋予一个实体类型的时候，接口会存储实体的类型信息，反射就是通过接口的类型信息实现的，反射建立在类型的基础上。

Go 语言在 reflect 包里定义了各种类型，实现了反射的各种函数，通过它们可以在运行时检测类型的信息、改变类型的值。

types 和 interface

Go 语言中，每个变量都有一个静态类型，在编译阶段就确定了的，比如 int,float64,[]int 等等。注意，这个类型是声明时候的类型，不是底层数据类型。

Go 官方博客里就举了一个例子：

  1. type MyInt int

  3. var i int
  4. var j MyInt
尽管 i，j 的底层类型都是 int，但我们知道，他们是不同的静态类型，除非进行类型转换，否则，i 和 j 不能同时出现在等号两侧。j 的静态类型就是 MyInt。
反射主要与 interface{} 类型相关。前面一篇关于 interface 相关的文章已经探讨过 interface 的底层结构，这里再来复习一下。
  1. type iface struct {
  2.     tab  *itab
  3.     data unsafe.Pointer
  4. }

  6. type itab struct {
  7.     inter  *interfacetype
  8.     _type  *_type
  9.     link   *itab
  10.     hash   uint32
  11.     bad    bool
  12.     inhash bool
  13.     unused [2]byte
  14.     fun    [1]uintptr
  15. }
其中 itab 由具体类型 _type 以及 interfacetype 组成。 _type 表示具体类型，而 interfacetype 则表示具体类型实现的接口类型。
https://img1.sycdn.imooc.com//5d3dae740001430906860657.jpg
实际上，iface 描述的是非空接口，它包含方法；与之相对的是 eface，描述的是空接口，不包含任何方法，Go 语言里有的类型都 “实现了” 空接口。
type eface struct {    _type *_type    data  unsafe.Pointer}
相比 iface， eface 就比较简单了。只维护了一个 _type 字段，表示空接口所承载的具体的实体类型。 data 描述了具体的值。
https://img1.sycdn.imooc.com//5d3dae7b0001361e02920306.jpg
还是用 Go 官方关于反射的博客里的例子，当然，我会用图形来详细解释，结合两者来看会更清楚。顺便提一下，搞技术的不要害怕英文资料，要想成为技术专家，读英文原始资料是技术提高的一条必经之路。
先明确一点：接口变量可以存储任何实现了接口定义的所有方法的变量。
Go 语言中最常见的就是 Reader 和 Writer 接口：
  1. type Reader interface {
  2.     Read(p []byte) (n int, err error)
  3. }

  5. type Writer interface {
  6.     Write(p []byte) (n int, err error)
  7. }
接下来，就是接口之间的各种转换和赋值了：
var r io.Readertty, err := os.OpenFile("/Users/qcrao/Desktop/test", os.O_RDWR, 0)if err != nil {    return nil, err}r = tty
首先声明 r 的类型是 io.Reader，注意，这是 r 的静态类型，此时它的动态类型为 nil，并且它的动态值也是 nil。
之后， r=tty 这一语句，将 r 的动态类型变成 *os.File，动态值则变成非空，表示打开的文件对象。这时，r 可以用 <value,type>对来表示为： <tty, *os.File>。
https://img1.sycdn.imooc.com//5d3daf3a000112b806950290.jpg
注意看上图，此时虽然 fun 所指向的函数只有一个 Read 函数，其实 *os.File 还包含 Write 函数，也就是说 *os.File 其实还实现了 io.Writer 接口。因此下面的断言语句可以执行：
var w io.Writerw = r.(io.Writer)
之所以用断言，而不能直接赋值，是因为 r 的静态类型是 io.Reader，并没有实现 io.Writer 接口。断言能否成功，看 r 的动态类型是否符合要求。
这样，w 也可以表示成 <tty, *os.File>，仅管它和 r 一样，但是 w 可调用的函数取决于它的静态类型 io.Writer，也就是说它只能有这样的调用形式： w.Write() 。 w 的内存形式如下图：
https://img1.sycdn.imooc.com//5d3daeff00017fac07040285.jpg
和 r 相比，仅仅是 fun 对应的函数变了： Read->Write。
最后，再来一个赋值：
var empty interface{}empty = w
由于 empty 是一个空接口，因此所有的类型都实现了它，w 可以直接赋给它，不需要执行断言操作。
https://img1.sycdn.imooc.com//5d3daeef0001821b06980182.jpg
从上面的三张图可以看到，interface 包含三部分信息： _type 是类型信息， *data指向实际类型的实际值， itab 包含实际类型的信息，包括大小、包路径，还包含绑定在类型上的各种方法（图上没有画出方法），补充一下关于 os.File 结构体的图：
https://img1.sycdn.imooc.com//5d3daed900015b0706960506.jpg
这一节的最后，复习一下上一篇关于 interface 的文章，提到的一个技巧，这里再展示一下：
先参考源码，分别定义一个 “伪装”的 iface 和 eface 结构体。
  1. type iface struct {
  2.     tab  *itab
  3.     data unsafe.Pointer
  4. }
  5. type itab struct {
  6.     inter uintptr
  7.     _type uintptr
  8.     link uintptr
  9.     hash  uint32
  10.     _     [4]byte
  11.     fun   [1]uintptr
  12. }

  14. type eface struct {
  15.     _type uintptr
  16.     data unsafe.Pointer
  17. }
接着，将接口变量占据的内存内容强制解释成上面定义的类型，再打印出来：
  1. package main

  3. import (
  4.     "os"
  5.     "fmt"
  6.     "io"
  7.     "unsafe"
  8. )

  10. func main() {
  11.     var r io.Reader
  12.     fmt.Printf("initial r: %T, %v\n", r, r)

  14.     tty, _ := os.OpenFile("/Users/qcrao/Desktop/test", os.O_RDWR, 0)
  15.     fmt.Printf("tty: %T, %v\n", tty, tty)

  17.     // 给 r 赋值
  18.     r = tty
  19.     fmt.Printf("r: %T, %v\n", r, r)

  21.     rIface := (*iface)(unsafe.Pointer(&r))
  22.     fmt.Printf("r: iface.tab._type = %#x, iface.data = %#x\n", rIface.tab._type, rIface.data)

  24.     // 给 w 赋值
  25.     var w io.Writer
  26.     w = r.(io.Writer)
  27.     fmt.Printf("w: %T, %v\n", w, w)

  29.     wIface := (*iface)(unsafe.Pointer(&w))
  30.     fmt.Printf("w: iface.tab._type = %#x, iface.data = %#x\n", wIface.tab._type, wIface.data)

  32.     // 给 empty 赋值
  33.     var empty interface{}
  34.     empty = w
  35.     fmt.Printf("empty: %T, %v\n", empty, empty)

  37.     emptyEface := (*eface)(unsafe.Pointer(&empty))
  38.     fmt.Printf("empty: eface._type = %#x, eface.data = %#x\n", emptyEface._type, emptyEface.data)
  39. }
运行结果：
initial r: <nil>, <nil>tty: *os.File, &{0xc4200820f0}r: *os.File, &{0xc4200820f0}r: iface.tab._type = 0x10bfcc0, iface.data = 0xc420080020w: *os.File, &{0xc4200820f0}w: iface.tab._type = 0x10bfcc0, iface.data = 0xc420080020empty: *os.File, &{0xc4200820f0}empty: eface._type = 0x10bfcc0, eface.data = 0xc420080020
r，w，empty 的动态类型和动态值都一样。不再详细解释了，结合前面的图可以看得非常清晰。
反射的基本函数
reflect 包里定义了一个接口和一个结构体，即 reflect.Type 和 reflect.Value，它们提供很多函数来获取存储在接口里的类型信息。
reflect.Type 主要提供关于类型相关的信息，所以它和 _type 关联比较紧密； reflect.Value 则结合 _type 和 data 两者，因此程序员可以获取甚至改变类型的值。
reflect 包中提供了两个基础的关于反射的函数来获取上述的接口和结构体：
func TypeOf(i interface{}) Type func ValueOf(i interface{}) Value
TypeOf 函数用来提取一个接口中值的类型信息。由于它的输入参数是一个空的 interface{}，调用此函数时，实参会先被转化为 interface{} 类型。这样，实参的类型信息、方法集、值信息都存储到 interface{} 变量里了。
看下源码：
func TypeOf(i interface{}) Type {    eface := *(*emptyInterface)(unsafe.Pointer(&i))    return toType(eface.typ)}
这里的 emptyInterface 和上面提到的 eface 是一回事（字段名略有差异，字段是相同的），且在不同的源码包：前者在 reflect 包，后者在 runtime 包。 eface.typ 就是动态类型。
type emptyInterface struct {    typ  *rtype    word unsafe.Pointer}
至于 toType 函数，只是做了一个类型转换：
func toType(t *rtype) Type {    if t == nil {        return nil    }    return t}
注意，返回值 Type 实际上是一个接口，定义了很多方法，用来获取类型相关的各种信息，而 *rtype 实现了 Type 接口。
  1. type Type interface {
  2.     // 所有的类型都可以调用下面这些函数

  4.     // 此类型的变量对齐后所占用的字节数
  5.     Align() int

  7.     // 如果是 struct 的字段，对齐后占用的字节数
  8.     FieldAlign() int

  10.     // 返回类型方法集里的第 `i` (传入的参数)个方法
  11.     Method(int) Method

  13.     // 通过名称获取方法
  14.     MethodByName(string) (Method, bool)

  16.     // 获取类型方法集里导出的方法个数
  17.     NumMethod() int

  19.     // 类型名称
  20.     Name() string

  22.     // 返回类型所在的路径，如：encoding/base64
  23.     PkgPath() string

  25.     // 返回类型的大小，和 unsafe.Sizeof 功能类似
  26.     Size() uintptr

  28.     // 返回类型的字符串表示形式
  29.     String() string

  31.     // 返回类型的类型值
  32.     Kind() Kind

  34.     // 类型是否实现了接口 u
  35.     Implements(u Type) bool

  37.     // 是否可以赋值给 u
  38.     AssignableTo(u Type) bool

  40.     // 是否可以类型转换成 u
  41.     ConvertibleTo(u Type) bool

  43.     // 类型是否可以比较
  44.     Comparable() bool

  46.     // 下面这些函数只有特定类型可以调用
  47.     // 如：Key, Elem 两个方法就只能是 Map 类型才能调用

  49.     // 类型所占据的位数
  50.     Bits() int

  52.     // 返回通道的方向，只能是 chan 类型调用
  53.     ChanDir() ChanDir

  55.     // 返回类型是否是可变参数，只能是 func 类型调用
  56.     // 比如 t 是类型 func(x int, y ... float64)
  57.     // 那么 t.IsVariadic() == true
  58.     IsVariadic() bool

  60.     // 返回内部子元素类型，只能由类型 Array, Chan, Map, Ptr, or Slice 调用
  61.     Elem() Type

  63.     // 返回结构体类型的第 i 个字段，只能是结构体类型调用
  64.     // 如果 i 超过了总字段数，就会 panic
  65.     Field(i int) StructField

  67.     // 返回嵌套的结构体的字段
  68.     FieldByIndex(index []int) StructField

  70.     // 通过字段名称获取字段
  71.     FieldByName(name string) (StructField, bool)

  73.     // FieldByNameFunc returns the struct field with a name
  74.     // 返回名称符合 func 函数的字段
  75.     FieldByNameFunc(match func(string) bool) (StructField, bool)

  77.     // 获取函数类型的第 i 个参数的类型
  78.     In(i int) Type

  80.     // 返回 map 的 key 类型，只能由类型 map 调用
  81.     Key() Type

  83.     // 返回 Array 的长度，只能由类型 Array 调用
  84.     Len() int

  86.     // 返回类型字段的数量，只能由类型 Struct 调用
  87.     NumField() int

  89.     // 返回函数类型的输入参数个数
  90.     NumIn() int

  92.     // 返回函数类型的返回值个数
  93.     NumOut() int

  95.     // 返回函数类型的第 i 个值的类型
  96.     Out(i int) Type

  98.     // 返回类型结构体的相同部分
  99.     common() *rtype

  101.     // 返回类型结构体的不同部分
  102.     uncommon() *uncommonType
  103. }
可见 Type 定义了非常多的方法，通过它们可以获取类型的一切信息，大家一定要完整的过一遍上面所有的方法。
注意到 Type 方法集的倒数第二个方法 common返回的 rtype类型，它和上一篇文章讲到的 _type 是一回事，而且源代码里也注释了：两边要保持同步：
 // rtype must be kept in sync with ../runtime/type.go:/^type._type.
type rtype struct {    size       uintptr    ptrdata    uintptr    hash       uint32    tflag      tflag    align      uint8    fieldAlign uint8    kind       uint8    alg        *typeAlg    gcdata     *byte    str        nameOff    ptrToThis  typeOff}
所有的类型都会包含 rtype 这个字段，表示各种类型的公共信息；另外，不同类型包含自己的一些独特的部分。
比如下面的 arrayType 和 chanType 都包含 rytpe，而前者还包含 slice，len 等和数组相关的信息；后者则包含 dir 表示通道方向的信息。
  1. // arrayType represents a fixed array type.
  2. type arrayType struct {
  3.     rtype `reflect:"array"`
  4.     elem  *rtype // array element type
  5.     slice *rtype // slice type
  6.     len   uintptr
  7. }

  9. // chanType represents a channel type.
  10. type chanType struct {
  11.     rtype `reflect:"chan"`
  12.     elem  *rtype  // channel element type
  13.     dir   uintptr // channel direction (ChanDir)
  14. }
注意到， Type 接口实现了 String() 函数，满足 fmt.Stringer 接口，因此使用 fmt.Println 打印的时候，输出的是 String() 的结果。另外， fmt.Printf()函数，如果使用 %T 来作为格式参数，输出的是 reflect.TypeOf 的结果，也就是动态类型。例如：
fmt.Printf("%T", 3) // int
讲完了 TypeOf 函数，再来看一下 ValueOf 函数。返回值 reflect.Value 表示 interface{} 里存储的实际变量，它能提供实际变量的各种信息。相关的方法常常是需要结合类型信息和值信息。例如，如果要提取一个结构体的字段信息，那就需要用到 _type (具体到这里是指 structType) 类型持有的关于结构体的字段信息、偏移信息，以及 *data 所指向的内容 —— 结构体的实际值。
源码如下：
  1. func ValueOf(i interface{}) Value {
  2.     if i == nil {
  3.         return Value{}
  4.     }

  6.    // ……
  7.     return unpackEface(i)
  8. }

  10. // 分解 eface
  11. func unpackEface(i interface{}) Value {
  12.     e := (*emptyInterface)(unsafe.Pointer(&i))

  14.     t := e.typ
  15.     if t == nil {
  16.         return Value{}
  17.     }

  19.     f := flag(t.Kind())
  20.     if ifaceIndir(t) {
  21.         f |= flagIndir
  22.     }
  23.     return Value{t, e.word, f}
  24. }
从源码看，比较简单：将先将 i 转换成 *emptyInterface 类型， 再将它的 typ 字段和 word 字段以及一个标志位字段组装成一个 Value 结构体，而这就是 ValueOf函数的返回值，它包含类型结构体指针、真实数据的地址、标志位。
Value 结构体定义了很多方法，通过这些方法可以直接操作 Value 字段 ptr 所指向的实际数据：
  1. // 设置切片的 len 字段，如果类型不是切片，就会panic
  2.  func (v Value) SetLen(n int)

  4.  // 设置切片的 cap 字段
  5.  func (v Value) SetCap(n int)

  7.  // 设置字典的 kv
  8.  func (v Value) SetMapIndex(key, val Value)

  10.  // 返回切片、字符串、数组的索引 i 处的值
  11.  func (v Value) Index(i int) Value

  13.  // 根据名称获取结构体的内部字段值
  14.  func (v Value) FieldByName(name string) Value

  16.  // ……
Value 字段还有很多其他的方法。例如：
  1. // 用来获取 int 类型的值
  2. func (v Value) Int() int64

  4. // 用来获取结构体字段（成员）数量
  5. func (v Value) NumField() int

  7. // 尝试向通道发送数据（不会阻塞）
  8. func (v Value) TrySend(x reflect.Value) bool

  10. // 通过参数列表 in 调用 v 值所代表的函数（或方法
  11. func (v Value) Call(in []Value) (r []Value) 

  13. // 调用变参长度可变的函数
  14. func (v Value) CallSlice(in []Value) []Value 
不一一列举了，反正是非常多。可以去 src/reflect/value.go 去看看源码，搜索 func(vValue) 就能看到。
另外，通过 Type() 方法和 Interface() 方法可以打通 interface、 Type、 Value 三者。Type() 方法也可以返回变量的类型信息，与 reflect.TypeOf() 函数等价。Interface() 方法可以将 Value 还原成原来的 interface。
这里引用老钱《快学Go语言第十五课——反射》的一张图：
https://img1.sycdn.imooc.com//5d3daf8d0001e6b807080641.jpg
总结一下： TypeOf() 函数返回一个接口，这个接口定义了一系列方法，利用这些方法可以获取关于类型的所有信息； ValueOf() 函数返回一个结构体变量，包含类型信息以及实际值。
用一张图来串一下：
https://img1.sycdn.imooc.com//5d3daf930001feb906950590.jpg
上图中， rtye 实现了 Type 接口，是所有类型的公共部分。emptyface 结构体和 eface 其实是一个东西，而 rtype 其实和 _type 是一个东西，只是一些字段稍微有点差别，比如 emptyface 的 word 字段和 eface 的 data 字段名称不同，但是数据型是一样的。
反射的三大定律
根据 Go 官方关于反射的博客，反射有三大定律：
  1. Reflection goes from interface value to reflection object.
  2. Reflection goes from reflection object to interface value.
  3. To modify a reflection object, the value must be settable.
第一条是最基本的：反射是一种检测存储在 interface 中的类型和值机制。这可以通过 TypeOf 函数和 ValueOf 函数得到。
第二条实际上和第一条是相反的机制，它将 ValueOf 的返回值通过 Interface() 函数反向转变成 interface 变量。
前两条就是说 接口型变量 和 反射类型对象 可以相互转化，反射类型对象实际上就是指的前面说的 reflect.Type 和 reflect.Value。
第三条不太好懂：如果需要操作一个反射变量，那么它必须是可设置的。反射变量可设置的本质是它存储了原变量本身，这样对反射变量的操作，就会反映到原变量本身；反之，如果反射变量不能代表原变量，那么操作了反射变量，不会对原变量产生任何影响，这会给使用者带来疑惑。所以第二种情况在语言层面是不被允许的。
举一个经典例子：
var x float64 = 3.4v := reflect.ValueOf(x)v.SetFloat(7.1) // Error: will panic.
执行上面的代码会产生 panic，原因是反射变量 v 不能代表 x 本身，为什么？因为调用 reflect.ValueOf(x) 这一行代码的时候，传入的参数在函数内部只是一个拷贝，是值传递，所以 v 代表的只是 x 的一个拷贝，因此对 v 进行操作是被禁止的。
可设置是反射变量 Value 的一个性质，但不是所有的 Value 都是可被设置的。
就像在一般的函数里那样，当我们想改变传入的变量时，使用指针就可以解决了。
var x float64 = 3.4p := reflect.ValueOf(&x)fmt.Println("type of p:", p.Type())fmt.Println("settability of p:", p.CanSet())
输出是这样的：
type of p: *float64settability of p: false
p 还不是代表 x， p.Elem() 才真正代表 x，这样就可以真正操作 x 了：
v := p.Elem()v.SetFloat(7.1)fmt.Println(v.Interface()) // 7.1fmt.Println(x) // 7.1
关于第三条，记住一句话：如果想要操作原变量，反射变量 Value 必须要 hold 住原变量的地址才行。
反射相关函数的使用
代码样例
网络上各种博客文章里使用反射的样例代码非常多，读过这篇文章后，基本没有看不懂的，哈哈！不过，我这里还是举一个例子，并讲解一番：
  1. package main

  3. import (
  4.     "reflect"
  5.     "fmt"
  6. )

  8. type Child struct {
  9.     Name     string
  10.     Grade    int
  11.     Handsome bool
  12. }

  14. type Adult struct {
  15.     ID         string `qson:"Name"`
  16.     Occupation string
  17.     Handsome   bool
  18. }

  20. // 如果输入参数 i 是 Slice，元素是结构体，有一个字段名为 `Handsome`，
  21. // 并且有一个字段的 tag 或者字段名是 `Name` ，
  22. // 如果该 `Name` 字段的值是 `qcrao`，
  23. // 就把结构体中名为 `Handsome` 的字段值设置为 true。
  24. func handsome(i interface{}) {
  25.     // 获取 i 的反射变量 Value
  26.     v := reflect.ValueOf(i)

  28.     // 确定 v 是一个 Slice
  29.     if v.Kind() != reflect.Slice {
  30.         return
  31.     }

  33.     // 确定 v 是的元素为结构体
  34.     if e := v.Type().Elem(); e.Kind() != reflect.Struct {
  35.         return
  36.     }

  38.     // 确定结构体的字段名含有 "ID" 或者 json tag 标签为 `name`
  39.     // 确定结构体的字段名 "Handsome"
  40.     st := v.Type().Elem()

  42.     // 寻找字段名为 Name 或者 tag 的值为 Name 的字段
  43.     foundName := false
  44.     for i := 0; i < st.NumField(); i++ {
  45.         f := st.Field(i)
  46.         tag := f.Tag.Get("qson")

  48.         if (tag == "Name" || f.Name == "Name") && f.Type.Kind() == reflect.String {
  49.             foundName = true
  50.             break
  51.         }
  52.     }

  54.     if !foundName {
  55.         return
  56.     }

  58.     if niceField, foundHandsome := st.FieldByName("Handsome"); foundHandsome == false || niceField.Type.Kind() != reflect.Bool {
  59.         return
  60.     }

  62.     // 设置名字为 "qcrao" 的对象的 "Handsome" 字段为 true
  63.     for i := 0; i < v.Len(); i++ {
  64.         e := v.Index(i)
  65.         handsome := e.FieldByName("Handsome")

  67.         // 寻找字段名为 Name 或者 tag 的值为 Name 的字段
  68.         var name reflect.Value
  69.         for j := 0; j < st.NumField(); j++ {
  70.             f := st.Field(j)
  71.             tag := f.Tag.Get("qson")

  73.             if tag == "Name" || f.Name == "Name" {
  74.                 name = v.Index(i).Field(j)
  75.             }
  76.         }

  78.         if name.String() == "qcrao" {
  79.             handsome.SetBool(true)
  80.         }
  81.     }
  82. }

  84. func main() {
  85.     children := []Child{
  86.         {Name: "Ava", Grade: 3, Handsome: true},
  87.         {Name: "qcrao", Grade: 6, Handsome: false},
  88.     }

  90.     adults := []Adult{
  91.         {ID: "Steve", Occupation: "Clerk", Handsome: true},
  92.         {ID: "qcrao", Occupation: "Go Programmer", Handsome: false},
  93.     }

  95.     fmt.Printf("adults before handsome: %v\n", adults)
  96.     handsome(adults)
  97.     fmt.Printf("adults after handsome: %v\n", adults)

  99.     fmt.Println("-------------")

  101.     fmt.Printf("children before handsome: %v\n", children)
  102.     handsome(children)
  103.     fmt.Printf("children after handsome: %v\n", children)
  104. }
代码运行结果：
adults before handsome: [{Steve Clerk true} {qcrao Go Programmer false}]adults after handsome: [{Steve Clerk true} {qcrao Go Programmer true}]-------------children before handsome: [{Ava 3 true} {qcrao 6 false}]children after handsome: [{Ava 3 true} {qcrao 6 true}]
代码主要做的事情是：找出传入的参数为 Slice，并且 Slice 的元素为结构体，如果其中有一个字段名是 Name 或者是 标签名称为 Name，并且还有一个字段名是 Handsome的情形。如果找到，并且字段名称为 Name 的实际值是 qcrao 的话，就把另一个字段 Handsome 的值置为 true。
程序并不关心传入的结构体到底是什么，只要它的字段名包含 Name 和 Handsome，都是 handsome 函数要工作的对象。
注意一点， Adult 结构体的标签 qson:"Name"，中间是没有空格的，否则 Tag.Get("qson") 识别不出来。
未导出成员
利用反射机制，对于结构体中未导出成员，可以读取，但不能修改其值。
注意，正常情况下，代码是不能读取结构体未导出成员的，但通过反射可以越过这层限制。另外，通过反射，结构体中可以被修改的成员只有是导出成员，也就是字段名的首字母是大写的。
一个可取地址的 reflect.Value 变量会记录一个结构体成员是否是未导出成员，如果是的话则拒绝修改操作。 CanAddr 不能说明一个变量是否可以被修改。 CanSet 则可以检查对应的 reflect.Value 是否可取地址并可被修改。
  1. package main

  3. import (
  4.     "reflect"
  5.     "fmt"
  6. )

  8. type Child struct {
  9.     Name     string
  10.     handsome bool
  11. }

  13. func main() {
  14.     qcrao := Child{Name: "qcrao", handsome: true}

  16.     v := reflect.ValueOf(&qcrao)

  18.     f := v.Elem().FieldByName("Name")
  19.     fmt.Println(f.String())

  21.     f.SetString("stefno")
  22.     fmt.Println(f.String())

  24.     f = v.Elem().FieldByName("handsome")

  26.     // 这一句会导致 panic，因为 handsome 字段未导出
  27.     //f.SetBool(true)
  28.     fmt.Println(f.Bool())
  29. }
执行结果：
qcraostefnotrue
上面的例子中，handsome 字段未导出，可以读取，但不能调用相关 set 方法，否则会 panic。反射用起来一定要小心，调用类型不匹配的方法，会导致各种 panic。
反射的实际应用
反射的实际应用非常广：IDE 中的代码自动补全功能、对象序列化（json 函数库）、fmt 相关函数的实现、ORM（全称是：Object Relational Mapping，对象关系映射）……
这里举 2 个例子：json 序列化和 DeepEqual 函数。
json 序列化
开发过 web 服务的同学，一定用过 json 数据格式。 json 是一种独立于语言的数据格式。最早用于浏览器和服务器之间的实时无状态的数据交换，并由此发展起来。
Go 语言中，主要提供 2 个函数用于序列化和反序列化：
func Marshal(v interface{}) ([]byte, error)func Unmarshal(data []byte, v interface{}) error
两个函数的参数都包含 interface，具体实现的时候，都会用到反射相关的特性。
对于序列化和反序列化函数，均需要知道参数的所有字段，包括字段类型和值，再调用相关的 get 函数或者 set 函数进行实际的操作。
DeepEqual 的作用及原理
在测试函数中，经常会需要这样的函数：判断两个变量的实际内容完全一致。
例如：如何判断两个 slice 所有的元素完全相同；如何判断两个 map 的 key 和 value 完全相同等等。
上述问题，可以通过 DeepEqual 函数实现。
func DeepEqual(x, y interface{}) bool
DeepEqual 函数的参数是两个 interface，实际上也就是可以输入任意类型，输出 true 或者 flase 表示输入的两个变量是否是“深度”相等。
先明白一点，如果是不同的类型，即使是底层类型相同，相应的值也相同，那么两者也不是“深度”相等。
  1. type MyInt int
  2. type YourInt int

  4. func main() {
  5.     m := MyInt(1)
  6.     y := YourInt(1)

  8.     fmt.Println(reflect.DeepEqual(m, y)) // false
  9. }
上面的代码中，m, y 底层都是 int，而且值都是 1，但是两者静态类型不同，前者是 MyInt，后者是 YourInt，因此两者不是“深度”相等。
在源码里，有对 DeepEqual 函数的非常清楚地注释，列举了不同类型，DeepEqual 的比较情形，这里做一个总结：
类型深度相等情形
Array相同索引处的元素“深度”相等
Struct相应字段，包含导出和不导出，“深度”相等
Func只有两者都是 nil 时
Interface两者存储的具体值“深度”相等
Map1、都为 nil；2、非空、长度相等，指向同一个 map 实体对象，或者相应的 key 指向的 value “深度”相等
Pointer1、使用 == 比较的结果相等；2、指向的实体“深度”相等
Slice1、都为 nil；2、非空、长度相等，首元素指向同一个底层数组的相同元素，即 &x[0] == &y[0] 或者 相同索引处的元素“深度”相等
numbers, bools, strings, and channels使用 == 比较的结果为真
一般情况下，DeepEqual 的实现只需要递归地调用 == 就可以比较两个变量是否是真的“深度”相等。
但是，有一些异常情况：比如 func 类型是不可比较的类型，只有在两个 func 类型都是 nil 的情况下，才是“深度”相等；float 类型，由于精度的原因，也是不能使用 == 比较的；包含 func 类型或者 float 类型的 struct， interface， array 等。
对于指针而言，当两个值相等的指针就是“深度”相等，因为两者指向的内容是相等的，即使两者指向的是 func 类型或者 float 类型，这种情况下不关心指针所指向的内容。
同样，对于指向相同 slice， map 的两个变量也是“深度”相等的，不关心 slice， map 具体的内容。
对于“有环”的类型，比如循环链表，比较两者是否“深度”相等的过程中，需要对已比较的内容作一个标记，一旦发现两个指针之前比较过，立即停止比较，并判定二者是深度相等的。这样做的原因是，及时停止比较，避免陷入无限循环。
来看源码：
func DeepEqual(x, y interface{}) bool {    if x == nil || y == nil {        return x == y    }    v1 := ValueOf(x)    v2 := ValueOf(y)    if v1.Type() != v2.Type() {        return false    }    return deepValueEqual(v1, v2, make(map[visit]bool), 0)}
首先查看两者是否有一个是 nil 的情况，这种情况下，只有两者都是 nil，函数才会返回 true。
接着，使用反射，获取x，y 的反射对象，并且立即比较两者的类型，根据前面的内容，这里实际上是动态类型，如果类型不同，直接返回 false。
最后，最核心的内容在子函数 deepValueEqual 中。
代码比较长，思路却比较简单清晰：核心是一个 switch 语句，识别输入参数的不同类型，分别递归调用 deepValueEqual 函数，一直递归到最基本的数据类型，比较 int，string 等可以直接得出 true 或者 false，再一层层地返回，最终得到“深度”相等的比较结果。
实际上，各种类型的比较套路比较相似，这里就直接节选一个稍微复杂一点的 map 类型的比较：
  1. // deepValueEqual 函数
  2. // ……

  4. case Map:
  5.     if v1.IsNil() != v2.IsNil() {
  6.         return false
  7.     }
  8.     if v1.Len() != v2.Len() {
  9.         return false
  10.     }
  11.     if v1.Pointer() == v2.Pointer() {
  12.         return true
  13.     }
  14.     for _, k := range v1.MapKeys() {
  15.         val1 := v1.MapIndex(k)
  16.         val2 := v2.MapIndex(k)
  17.         if !val1.IsValid() || !val2.IsValid() || !deepValueEqual(v1.MapIndex(k), v2.MapIndex(k), visited, depth+1) {
  18.             return false
  19.         }
  20.     }
  21.     return true

  23. // ……    
和前文总结的表格里，比较 map 是否相等的思路比较一致，也不需要多说什么。说明一点，visited 是一个 map，记录递归过程中，比较过的“对”：
  1. type visit struct {
  2.     a1  unsafe.Pointer
  3.     a2  unsafe.Pointer
  4.     typ Type
  5. }

  7. map[visit]bool
比较过程中，一旦发现比较的“对”，已经在 map 里出现过的话，直接判定“深度”比较结果的是 true。
总结
Go 作为一门静态语言，相比 Python 等动态语言，在编写过程中灵活性会受到一定的限制。但是通过接口加反射实现了类似于动态语言的能力：可以在程序运行时动态地捕获甚至改变类型的信息和值。
Go 语言的反射实现的基础是类型，或者说是 interface，当我们使用反射特性时，实际上用到的就是存储在 interface 变量中的和类型相关的信息，也就是常说的 <type,value> 对。
只有 interface 才有反射的说法。
反射在 reflect 包中实现，涉及到两个相关函数：
func TypeOf ( i interface{} ) Typefunc ValueOf ( i interface{} ) Value
Type 是一个接口，定义了很多相关方法，用于获取类型信息。Value 则持有类型的具体值。Type、Value、Interface 三者间通过函数 TypeOf，ValueOf，Interface 进行相互转换。
最后温习一下反射三大定律：
  1. Reflection goes from interface value to reflection object.
  2. Reflection goes from reflection object to interface value.
  3. To modify a reflection object, the value must be settable.
翻译一下：
  1. 反射将接口变量转换成反射对象 Type 和 Value；
  2. 反射可以通过反射对象 Value 还原成原先的接口变量；
  3. 反射可以用来修改一个变量的值，前提是这个值可以被修改。
参考资料
【维基百科中文】https://zh.wikipedia.org/wiki/%E5%8F%8D%E5%B0%84_(%E8%AE%A1%E7%AE%97%E6%9C%BA%E7%A7%91%E5%AD%A6)
【码洞老钱 反射】https://juejin.im/post/5c2040d76fb9a049c643d9bd
【Go官方博客 reflection】https://blog.golang.org/laws-of-reflection
【GCTT译文，不错】https://mp.weixin.qq.com/s/dkgJ_fA0smvpv69t5Nv-7A
【json库 源码分析】https://zhuanlan.zhihu.com/p/37165706
【reflect 代码例子和图比较好】https://blog.gopheracademy.com/advent-2018/interfaces-and-reflect/
【反射使用讲得不错】https://juejin.im/post/5a75a4fb5188257a82110544
【接口和反射的关系 ，english】https://blog.gopheracademy.com/advent-2018/interfaces-and-reflect/
【总结成知识点】http://www.cnblogs.com/susufufu/p/7653579.html
【Type Value】https://colobu.com/2016/07/09/dive-into-go-13/
【讲得比较清晰简单】https://www.lijiaocn.com/%E7%BC%96%E7%A8%8B/2017/11/06/golang-reflection.html
【DeepEqual】https://github.com/Chasiny/Blog/blob/master/blog/go/package/go-reflect-deepequal.md
【反射使用场景】https://yq.aliyun.com/articles/599584



					

					

						

						
点击查看更多内容

					

				

				
												 
				
				
				

					

						

							发表于 2019.07.28 22:22， 
							共 1437 人浏览
						

						
本文原创发布于慕课网 ，转载请注明出处，谢谢合作
    
					

					

					
					举报
					
					

				

				
				

										
															
为 TA 点赞

										

						

							
若觉得本文不错，就分享一下吧！

							
						
	
					

				

				
							

			
		
	

		


		

			

				
 评论

				
			

		

		

			

				

				
作者其他优质文章

			

			

				

					
				

				
				

					正在加载中
				

			

		

	

	

				
		

			
				
			
			

				

					

					 	
						码农桃花源
						
					

				

				

					软件工程师
					
																		
						       
											
				

				
			

            

                

                    
手记

                    篇
                

                

                    
粉丝 

                    
88

                

                

                    
获赞与收藏

                    
320

                

            

            				

					关注作者，订阅最新文章
				

					
   
		
				
				
		
		

			
阅读免费教程

			
		

		
		
		
		

		                                        
		
		
		
		
	





	
    
		 
		
  • 
						
										推荐
					
    • 
		
		
  • 
			  
							评论
					
    • 
		
  • 
							
				收藏   
					
    •      
		
  • 共同学习，写下你的评论
    • 
		
  • 
			
			
			
			                                  
		
    • 
	







	

	

		

			
		

		
感谢您的支持，我会继续努力的～

		
扫码打赏，你说多少就多少

		
		
		
赞赏金额会直接到老师账户

		
支付方式

		

			

				

			

			

				

			

		

		
打开微信扫一扫，即可进行扫码打赏哦

	







	
	







	
今天注册有机会得

	

		
100积分直接送

		
付费专栏免费学

		
大额优惠券免费领

	

	立即参与
	放弃机会











    
        
        意见反馈
    
    
    
    
        
        帮助中心
    
    
        
        APP下载
        

    
    
        
        官方微信
        

    
    








































	

		
举报

		
	

	

		

		  	

			

			

		

	

	

		
		
0/150

	

	

		
提交

		
取消