《Go语言四十二章经》第二十七章 反射(reflect)

作者：李骁

27.1 反射(reflect)

反射是应用程序检查其所拥有的结构，尤其是类型的一种能。每种语言的反射模型都不同，并且有些语言根本不支持反射。Go语言实现了反射，反射机制就是在运行时动态调用对象的方法和属性，即可从运行时态的示例对象反求其编码阶段的定义，标准库中reflect包提供了相关的功能。在reflect包中，通过reflect.TypeOf()，reflect.ValueOf()分别从类型、值的角度来描述一个Go对象。

  1. func TypeOf(i interface{}) Type
  2. type Type interface 
  4. func ValueOf(i interface{}) Value
  5. type Value struct

在Go语言的实现中，一个interface类型的变量存储了2个信息, 一个<值，类型>对， :

  1. (value, type)

value是实际变量值，type是实际变量的类型。两个简单的函数，reflect.TypeOf 和 reflect.ValueOf，返回被检查对象的类型和值。

例如，x 被定义为：var x float64 = 3.4，那么 reflect.TypeOf(x) 返回 float64，reflect.ValueOf(x) 返回 3.4。实际上，反射是通过检查一个接口的值，变量首先被转换成空接口。这从下面两个函数签名能够很明显的看出来：

  1. func TypeOf(i interface{}) Type
  2. func ValueOf(i interface{}) Value

reflect.Type 和 reflect.Value 都有许多方法用于检查和操作它们。

Type主要有：Kind() 将返回一个常量，表示具体类型的底层类型Elem()方法返回指针、数组、切片、字典、通道的基类型，这个方法要慎用，如果用在其他类型上面会出现panic

Value主要有：Type() 将返回具体类型所对应的 reflect.Type（静态类型）Kind() 将返回一个常量，表示具体类型的底层类型

反射可以在运行时检查类型和变量，例如它的大小、方法和 动态 的调用这些方法。这对于没有源代码的包尤其有用。

由于反射是一个强大的工具，但反射对性能有一定的影响，除非有必要，否则应当避免使用或小心使用。下面代码针对int、数组以及结构体分别使用反射机制，其中的差异请看注释。

  1. package main
  3. import (
  4.     "fmt"
  5.     "reflect"
  6. )
  8. type Student struct {
  9.     name string
  10. }
  12. func main() {
  14.     var a int = 50
  15.     v := reflect.ValueOf(a) // 返回Value类型对象，值为50
  16.     t := reflect.TypeOf(a)  // 返回Type类型对象，值为int
  17.     fmt.Println(v, t, v.Type(), t.Kind())
  19.     var b [5]int = [5]int{5, 6, 7, 8}
  20.     fmt.Println(reflect.TypeOf(b), reflect.TypeOf(b).Kind(),reflect.TypeOf(b).Elem()) // [5]int array int
  22.     var Pupil Student
  23.     p := reflect.ValueOf(Pupil) // 使用ValueOf()获取到结构体的Value对象
  25.     fmt.Println(p.Type()) // 输出:Student
  26.     fmt.Println(p.Kind()) // 输出:struct
  28. }

在Go语言中，类型包括 static type和concrete type. 简单说 static type是你在编码是看见的类型(如int、string)，concrete type是实际具体的类型，runtime系统看见的类型。

Type()返回的是静态类型，而kind()返回的是具体类型。上面代码中，在int，数组以及结构体三种类型情况中，可以看到kind()，type()返回值的差异。

通过反射可以修改原对象

d.CanAddr()方法：判断它是否可被取地址d.CanSet()方法：判断它是否可被取地址并可被修改

通过一个settable的Value反射对象来访问、修改其对应的变量值：

  1. package main
  3. import (
  4.     "fmt"
  5.     "reflect"
  6. )
  8. type Student struct {
  9.     name string
  10.     Age  int
  11. }
  13. func main() {
  15.     var a int = 50
  16.     v := reflect.ValueOf(a) // 返回Value类型对象，值为50
  17.     t := reflect.TypeOf(a)  // 返回Type类型对象，值为int
  18.     fmt.Println(v, t, v.Type(), t.Kind(), reflect.ValueOf(&a).Elem())
  19.     seta := reflect.ValueOf(&a).Elem() // 这样才能让seta保存a的值
  20.     fmt.Println(seta, seta.CanSet())
  21.     seta.SetInt(1000)
  22.     fmt.Println(seta)
  24.     var b [5]int = [5]int{5, 6, 7, 8}
  25.     fmt.Println(reflect.TypeOf(b), reflect.TypeOf(b).Kind(), reflect.TypeOf(b).Elem())
  27.     var Pupil Student = Student{"joke", 18}
  28.     p := reflect.ValueOf(Pupil) // 使用ValueOf()获取到结构体的Value对象
  30.     fmt.Println(p.Type()) // 输出:Student
  31.     fmt.Println(p.Kind()) // 输出:struct
  33.     setStudent := reflect.ValueOf(&Pupil).Elem()
  34.     //setStudent.Field(0).SetString("Mike") // 未导出字段，不能修改，panic会发生
  35.     setStudent.Field(1).SetInt(19)
  36.     fmt.Println(setStudent)
  38. }

虽然反射可以越过Go语言的导出规则的限制读取结构体中未导出的成员，但不能修改这些未导出的成员。因为一个结构体中只有被导出的字段才是可修改的。

在结构体中有tag标签，通过反射可获取结构体成员变量的tag信息。

  1. package main
  3. import (
  4.     "fmt"
  5.     "reflect"
  6. )
  8. type Student struct {
  9.     name string
  10.     Age  int `json:"years"`
  11. }
  13. func main() {
  14.     var Pupil Student = Student{"joke", 18}
  15.     setStudent := reflect.ValueOf(&Pupil).Elem()
  17.     sSAge, _ := setStudent.Type().FieldByName("Age")
  18.     fmt.Println(sSAge.Tag.Get("json")) // years
  19. }
  1. 程序输出：
  2. years

27.2 反射结构体

为了完整说明反射的情况，通过反射一个结构体类型，综合来说明。下面例子较为系统地利用一个结构体，来充分举例说明反射：

  1. package main
  3. import (
  4.     "fmt"
  5.     "reflect"
  6. )
  8. // 结构体
  9. type ss struct {
  10.     int
  11.     string
  12.     bool
  13.     float64
  14. }
  16. func (s ss) Method1(i int) string  { return "结构体方法1" }
  17. func (s *ss) Method2(i int) string { return "结构体方法2" }
  19. var (
  20.     structValue = ss{ // 结构体
  21.         20, 
  22.         "结构体", 
  23.         false, 
  24.         64.0, 
  25.     }
  26. )
  28. // 复杂类型
  29. var complexTypes = []interface{}{
  30.     structValue, &structValue, // 结构体
  31.     structValue.Method1, structValue.Method2, // 方法
  32. }
  34. func main() {
  35.     // 测试复杂类型
  36.     for i := 0; i < len(complexTypes); i++ {
  37.         PrintInfo(complexTypes[i])
  38.     }
  39. }
  41. func PrintInfo(i interface{}) {
  42.     if i == nil {
  43.         fmt.Println("--------------------")
  44.         fmt.Printf("无效接口值：%v\n", i)
  45.         fmt.Println("--------------------")
  46.         return
  47.     }
  48.     v := reflect.ValueOf(i)
  49.     PrintValue(v)
  50. }
  52. func PrintValue(v reflect.Value) {
  53.     fmt.Println("--------------------")
  54.     // ----- 通用方法 -----
  55.     fmt.Println("String             :", v.String())  // 反射值的字符串形式
  56.     fmt.Println("Type               :", v.Type())    // 反射值的类型
  57.     fmt.Println("Kind               :", v.Kind())    // 反射值的类别
  58.     fmt.Println("CanAddr            :", v.CanAddr()) // 是否可以获取地址
  59.     fmt.Println("CanSet             :", v.CanSet())  // 是否可以修改
  60.     if v.CanAddr() {
  61.         fmt.Println("Addr               :", v.Addr())       // 获取地址
  62.         fmt.Println("UnsafeAddr         :", v.UnsafeAddr()) // 获取自由地址
  63.     }
  64.     // 获取方法数量
  65.     fmt.Println("NumMethod          :", v.NumMethod())
  66.     if v.NumMethod() > 0 {
  67.         // 遍历方法
  68.         i := 0
  69.         for ; i < v.NumMethod()-1; i++ {
  70.             fmt.Printf("    ┣ %v\n", v.Method(i).String())
  71.             //            if i >= 4 { // 只列举 5 个
  72.             //                fmt.Println("    ┗ ...")
  73.             //                break
  74.             //            }
  75.         }
  76.         fmt.Printf("    ┗ %v\n", v.Method(i).String())
  77.         // 通过名称获取方法
  78.         fmt.Println("MethodByName       :", v.MethodByName("String").String())
  79.     }
  81.     switch v.Kind() {
  82.     // 结构体：
  83.     case reflect.Struct:
  84.         fmt.Println("=== 结构体 ===")
  85.         // 获取字段个数
  86.         fmt.Println("NumField           :", v.NumField())
  87.         if v.NumField() > 0 {
  88.             var i int
  89.             // 遍历结构体字段
  90.             for i = 0; i < v.NumField()-1; i++ {
  91.                 field := v.Field(i) // 获取结构体字段
  92.                 fmt.Printf("    ├ %-8v %v\n", field.Type(), field.String())
  93.             }
  94.             field := v.Field(i) // 获取结构体字段
  95.             fmt.Printf("    └ %-8v %v\n", field.Type(), field.String())
  96.             // 通过名称查找字段
  97.             if v := v.FieldByName("ptr"); v.IsValid() {
  98.                 fmt.Println("FieldByName(ptr)   :", v.Type().Name())
  99.             }
  100.             // 通过函数查找字段
  101.             v := v.FieldByNameFunc(func(s string) bool { return len(s) > 3 })
  102.             if v.IsValid() {
  103.                 fmt.Println("FieldByNameFunc    :", v.Type().Name())
  104.             }
  105.         }
  106.     }
  107. }
  1. 程序输出：
  2. String             : <main.ss Value>
  3. Type               : main.ss
  4. Kind               : struct
  5. CanAddr            : false
  6. CanSet             : false
  7. NumMethod          : 1
  8.     ┗ <func(int) string Value>
  9. MethodByName       : <invalid Value>
  10. === 结构体 ===
  11. NumField           : 4
  12.     ├ int      <int Value>
  13.     ├ string   结构体
  14.     ├ bool     <bool Value>
  15.     └ float64  <float64 Value>
  16. --------------------
  17. String             : <*main.ss Value>
  18. Type               : *main.ss
  19. Kind               : ptr
  20. CanAddr            : false
  21. CanSet             : false
  22. NumMethod          : 2
  23.     ┣ <func(int) string Value>
  24.     ┗ <func(int) string Value>
  25. MethodByName       : <invalid Value>
  26. --------------------
  27. String             : <func(int) string Value>
  28. Type               : func(int) string
  29. Kind               : func
  30. CanAddr            : false
  31. CanSet             : false
  32. NumMethod          : 0
  33. --------------------
  34. String             : <func(int) string Value>
  35. Type               : func(int) string
  36. Kind               : func
  37. CanAddr            : false
  38. CanSet             : false
  39. NumMethod          : 0

细心的读者可能发现了上面代码中的一个有趣的问题，那就是structValue, &structValue的反射结果是不一样的，指针对象在这里有两个方法，而值对象只有一个方法，这是因为Method2()方法是指针方法，在值对象中是不能被反射到的。

第二十六章 测试

第二十八章 unsafe包

本书《Go语言四十二章经》内容在github上同步地址：https://github.com/ffhelicopter/Go42

虽然本书中例子都经过实际运行，但难免出现错误和不足之处，烦请您指出；如有建议也欢迎交流。