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

作者：李骁

27.1 反射(reflect)

反射是用程序检查其所拥有的结构，尤其是类型的一种能力；这是元编程的一种形式。

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

这是一个强大的工具，除非真得有必要，否则应当避免使用或小心使用。

变量的最基本信息就是类型和值。反射包的 Type 用来表示一个 Go 类型，反射包的 Value 为 Go 值提供了反射接口。

两个简单的函数，reflect.TypeOf 和 reflect.ValueOf，返回被检查对象的类型和值。

例如，x 被定义为：var x float64 = 3.4，那么 reflect.TypeOf(x) 返回 float64，reflect.ValueOf(x) 返回

实际上，反射是通过检查一个接口的值，变量首先被转换成空接口。这从下面两个函数签名能够很明显的看出来：

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

接口的值包含一个 type 和 value。

反射可以从接口值反射到对象，也可以从对象反射回接口值。

reflect.Type 和 reflect.Value 都有许多方法用于检查和操作它们。一个重要的例子是 Value 有一个 Type 方法返回 reflect.Value 的 Type。另一个是 Type 和 Value 都有 Kind 方法返回一个常量来表示类型：Uint、Float64、Slice 等等。同样 Value 有叫做 Int 和 Float 的方法可以获取存储在内部的值（跟 int64 和 float64 一样）

问题的原因是 v 不是可设置的（这里并不是说值不可寻址）。是否可设置是 Value 的一个属性，并且不是所有的反射值都有这个属性：可以使用 CanSet() 方法测试是否可设置。反射中有些内容是需要用地址去改变它的状态的。
当 v := reflect.ValueOf(x) 函数通过传递一个 x 拷贝创建了 v，那么 v 的改变并不能更改原始的 x。要想 v 的更改能作用到 x，那就必须传递 x 的地址 v = reflect.ValueOf(&x)。

通过 Type() 我们看到 v 现在的类型是 *float64 并且仍然是不可设置的。
要想让其可设置我们需要使用 Elem() 函数，这间接的使用指针：v = v.Elem()
现在 v.CanSet() 返回 true 并且 v.SetFloat(3.1415) 设置成功了！

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. }