基本介绍

反射的本质是运行时，编译的时候不参与
import “reflect”
reflect包实现了运行时反射，允许程序操作任意类型的对象。典型用法是用静态类型interface{}保存一个值，通过调用TypeOf获取其动态类型信息，该函数返回一个Type类型值。调用ValueOf函数返回一个Value类型值，该值代表运行时的数据。Zero接受一个Type类型参数并返回一个代表该类型零值的Value类型值。

反射重要的函数和概念

1、reflect.TypeOf(变量名)，获取变量的类型，返回reflect.Type类型
2、reflect.ValueOf(变量名)，获取变量的值，返回reflect.Value类型reflect.Value 是一个结构体类型。【看文档】，通过reflect.Value，可以获取到关于该变量的很多信息。

  1. type Type interface {
  2.     // Kind返回该接口的具体分类
  3.     Kind() Kind
  4.     // Name返回该类型在自身包内的类型名，如果是未命名类型会返回""
  5.     Name() string
  6.     // PkgPath返回类型的包路径，即明确指定包的import路径，如"encoding/base64"
  7.     // 如果类型为内建类型(string, error)或未命名类型(*T, struct{}, []int)，会返回""
  8.     PkgPath() string
  9.     // 返回类型的字符串表示。该字符串可能会使用短包名（如用base64代替"encoding/base64"）
  10.     // 也不保证每个类型的字符串表示不同。如果要比较两个类型是否相等，请直接用Type类型比较。
  11.     String() string
  12.     // 返回要保存一个该类型的值需要多少字节；类似unsafe.Sizeof
  13.     Size() uintptr
  14.     // 返回当从内存中申请一个该类型值时，会对齐的字节数
  15.     Align() int
  16.     // 返回当该类型作为结构体的字段时，会对齐的字节数
  17.     FieldAlign() int
  18.     // 如果该类型实现了u代表的接口，会返回真
  19.     Implements(u Type) bool
  20.     // 如果该类型的值可以直接赋值给u代表的类型，返回真
  21.     AssignableTo(u Type) bool
  22.     // 如该类型的值可以转换为u代表的类型，返回真
  23.     ConvertibleTo(u Type) bool
  24.     // 返回该类型的字位数。如果该类型的Kind不是Int、Uint、Float或Complex，会panic
  25.     Bits() int
  26.     // 返回array类型的长度，如非数组类型将panic
  27.     Len() int
  28.     // 返回该类型的元素类型，如果该类型的Kind不是Array、Chan、Map、Ptr或Slice，会panic
  29.     Elem() Type
  30.     // 返回map类型的键的类型。如非映射类型将panic
  31.     Key() Type
  32.     // 返回一个channel类型的方向，如非通道类型将会panic
  33.     ChanDir() ChanDir
  34.     // 返回struct类型的字段数（匿名字段算作一个字段），如非结构体类型将panic
  35.     NumField() int
  36.     // 返回struct类型的第i个字段的类型，如非结构体或者i不在[0, NumField())内将会panic
  37.     Field(i int) StructField
  38.     // 返回索引序列指定的嵌套字段的类型，
  39.     // 等价于用索引中每个值链式调用本方法，如非结构体将会panic
  40.     FieldByIndex(index []int) StructField
  41.     // 返回该类型名为name的字段（会查找匿名字段及其子字段），
  42.     // 布尔值说明是否找到，如非结构体将panic
  43.     FieldByName(name string) (StructField, bool)
  44.     // 返回该类型第一个字段名满足函数match的字段，布尔值说明是否找到，如非结构体将会panic
  45.     FieldByNameFunc(match func(string) bool) (StructField, bool)
  46.     // 如果函数类型的最后一个输入参数是"..."形式的参数，IsVariadic返回真
  47.     // 如果这样，t.In(t.NumIn() - 1)返回参数的隐式的实际类型（声明类型的切片）
  48.     // 如非函数类型将panic
  49.     IsVariadic() bool
  50.     // 返回func类型的参数个数，如果不是函数，将会panic
  51.     NumIn() int
  52.     // 返回func类型的第i个参数的类型，如非函数或者i不在[0, NumIn())内将会panic
  53.     In(i int) Type
  54.     // 返回func类型的返回值个数，如果不是函数，将会panic
  55.     NumOut() int
  56.     // 返回func类型的第i个返回值的类型，如非函数或者i不在[0, NumOut())内将会panic
  57.     Out(i int) Type
  58.     // 返回该类型的方法集中方法的数目
  59.     // 匿名字段的方法会被计算；主体类型的方法会屏蔽匿名字段的同名方法；
  60.     // 匿名字段导致的歧义方法会滤除
  61.     NumMethod() int
  62.     // 返回该类型方法集中的第i个方法，i不在[0, NumMethod())范围内时，将导致panic
  63.     // 对非接口类型T或*T，返回值的Type字段和Func字段描述方法的未绑定函数状态
  64.     // 对接口类型，返回值的Type字段描述方法的签名，Func字段为nil
  65.     Method(int) Method
  66.     // 根据方法名返回该类型方法集中的方法，使用一个布尔值说明是否发现该方法
  67.     // 对非接口类型T或*T，返回值的Type字段和Func字段描述方法的未绑定函数状态
  68.     // 对接口类型，返回值的Type字段描述方法的签名，Func字段为nil
  69.     MethodByName(string) (Method, bool)
  70.     // 内含隐藏或非导出方法
  71. }

image.png

反射示意图

image.png

反射的转化

image.png
image.png

功能代码初体验

  1. // 反射 reflect
  2. package main
  4. import (
  5.     "fmt"
  6.     "reflect"
  7. )
  9. // 基本数据类型反射
  10. func reflecttest01(b interface{}) {
  11.     // 通过反射获取到变量的 Type 信息
  12.     rTyp := reflect.TypeOf(b)
  13.     fmt.Printf("rTyp类型： %T, 值： %v \n", rTyp, rTyp) // rTyp类型： *reflect.rtype, 值： int
  14.     fmt.Println("rTyp.Name", rTyp.Name())
  16.     // 获取 reflect.Value
  17.     rVal := reflect.ValueOf(b)
  18.     fmt.Printf("rVal类型： %T, 值： %v \n", rVal, rVal) // rVal类型： reflect.Value, 值： 100
  19.     fmt.Println("rVal Kind : ", rVal.Kind())       // int
  20.     n2 := 10 + rVal.Int()
  21.     fmt.Println("原始值： ", rVal.Int()) // 原始值：  100
  22.     fmt.Println("n2 = ", n2)         // 110
  24.     // 将 rVal 转成 interface{}
  25.     iV := rVal.Interface()
  26.     fmt.Printf("iV 类型： %T， 值： %v \n", iV, iV) // iV 类型： int， 值： 100
  27.     // 断言
  28.     num2 := iV.(int)
  29.     fmt.Printf("num2 类型： %T， 值： %v \n", num2, num2) // num2 类型： int， 值： 100
  30. }
  32. // 结构体类型反射
  33. func reflecttest02(b interface{}) {
  34.     // 通过反射获取到变量的 Type 信息
  35.     rTyp := reflect.TypeOf(b)
  36.     fmt.Printf("rTyp类型： %T, 值： %v \n", rTyp, rTyp) // rTyp类型： *reflect.rtype, 值： main.Stu
  37.     fmt.Println("rTyp.Name", rTyp.Name())          // rTyp.Name Stu
  39.     // 获取 reflect.Value
  40.     rVal := reflect.ValueOf(b)
  41.     fmt.Printf("rVal类型： %T, 值： %v \n", rVal, rVal) // rVal类型： reflect.Value, 值： {tom 20}
  42.     fmt.Println("rVal Kind : ", rVal.Kind())       // rVal Kind :  struct
  44.     // 将 rVal 转成 interface{}
  45.     iV := rVal.Interface()
  46.     fmt.Printf("iV 类型： %T， 值： %v \n", iV, iV) // iV 类型： main.Stu， 值： {tom 20}
  47.     // 虽然 iv的 值是 {tom 20}， 但是仍然无法直接取出 Name,
  48.     // 反射是运行时，不是编译时，仍需要断言
  49.     // fmt.Printf("name = %v \n", iV.Name) // iV.Name undefined (type interface {} is interface with no methods)
  50.     // 带检测的断言 或者采用 switch type 的方式
  51.     _stu, ok := iV.(Stu)
  52.     if ok {
  53.         fmt.Printf("_stu 类型： %T， 值： %v \n", _stu, _stu) // _stu 类型： main.Stu， 值： {tom 20}
  54.         fmt.Printf("name = %v \n", _stu.Name)
  55.     } else {
  56.         fmt.Println("断言失败")
  57.     }
  58. }
  60. type Stu struct {
  61.     Name string
  62.     Age  int
  63. }
  65. func main() {
  66.     // 基本数据类型 - interface{} - reflect.ValueOf()
  67.     var num int = 100
  68.     reflecttest01(num)
  70.     // 结构体数据类型 - interface{} - reflect.ValueOf()
  71.     var stu Stu = Stu{
  72.         Name: "tom",
  73.         Age:  20,
  74.     }
  75.     reflecttest02(stu)
  76. }

反射截断（hack）

通过反射修改源数据
func (v Value) Elem() Value
Elem返回v持有的接口保管的值的Value封装，或者v持有的指针指向的值的Value封装。如果v的Kind不是Interface或Ptr会panic；如果v持有的值为nil，会返回Value零值。

指针类型传递，然后 调用 Elem().SetXxx()

  1. // 反射 reflect
  2. package main
  4. import (
  5.     "fmt"
  6.     "reflect"
  7. )
  9. // 基本数据类型反射
  10. func reflecttest01(b interface{}) {
  11.     // 通过反射获取到变量的 Type 信息
  12.     rTyp := reflect.TypeOf(b)
  13.     fmt.Printf("rTyp类型： %T, 值： %v \n", rTyp, rTyp) // rTyp类型： *reflect.rtype, 值： int
  14.     fmt.Println("rTyp.Name", rTyp.Name())
  16.     // 获取 reflect.Value
  17.     rVal := reflect.ValueOf(b)
  18.     fmt.Printf("rVal类型： %T, 值： %v \n", rVal, rVal) // rVal类型： reflect.Value, 值： 100
  19.     fmt.Println("rVal Kind : ", rVal.Kind())       // int
  20.     // n2 := 10 + rVal.Int()
  21.     // fmt.Println("原始值： ", rVal.Int()) // 原始值：  100
  22.     // fmt.Println("n2 = ", n2)         // 110
  24.     // rVal.SetInt(20) // panic: reflect: reflect.Value.SetInt using unaddressable value
  25.     rVal.Elem().SetInt(20)
  27.     // 将 rVal 转成 interface{}
  28.     iV := rVal.Interface()
  29.     fmt.Printf("iV 类型： %T， 值： %v \n", iV, iV) // iV 类型： int， 值： 100
  30.     // 断言
  31.     num2, ok := iV.(int)
  32.     if ok {
  33.         fmt.Printf("num2 类型： %T， 值： %v \n", num2, num2) // num2 类型： int， 值： 100
  34.     } else {
  35.         fmt.Println("断言失败XXXX")
  36.     }
  37. }
  39. func main() {
  40.     // 基本数据类型 - interface{} - reflect.ValueOf()
  41.     var num int = 100
  42.     reflecttest01(&num)
  43.     fmt.Println("num ===== ", num) // 20
  44. }