本文最后修改时间:2019-01-14 20:53

Go-learning

9.语言详解--反射

9.1 类型

  • 反射(reflect)让我们能在运行期弹指对象的类型信息和内存结构,弥补了静态语言上的不足。

  • 反射还是实现元编程的重要手段。

  • 和C数据结构一样的,GO对象头部并没有类型指针,通过其自身是无法在运行期获知任何类型相关的信息的。反射操作所需要的全部信息都源自接口变量。

  • 接口变量除存储自身类型外, 还会保存实际对象的类型数据。

func TypeOf(i interface{}) Type
func ValueOf(i interface{}) Value
  • 这两个反射入口函数,会将任何传入的对象转换为接口类型。

  • 在面对类型时,需要区分type和kind。前者辨识真是类型(静态类型),后者表示其基础结构(底层类型)区别。

type x int

func main() {
   var a X = 100
   t := reflect.TypeOf(a)

   fmt.Println(t.Name(), t.kind())
}
  • 输出:
x int
  • 所以在类型判断上,需选择正确的方式。
type X int
type Y int

func main()  {
    var a, b x = 100, 200
    var c    y = 300

    ta, tb, tc := reflect.TypeOf(a), reflect.TypeOf(b), reflect.TypeOf(c)

    fmt.Println(ta == tb, ta == tc)
    fmt.Println(ta.kind() == tc.kind())
}

  • 输出:
true false
true
  • 除通过实际对象获取类型外,也可直接构造一些基础符合类型。
func main()  {
    a := reflect.ArrayOf(10, reflect.TypeOf(byte(0)))
    m := reflect.MapOf(reflect.TypeOf(""), reflect.TypeOf(0))

    fmt.Println(a, m)
}

输出:

[10]uint8 map[string]int
  • 传入对象应区分基类型和指针类型,因为他们并不属于同一类型。
func main()  {
    x := 10

    tx, tp := reflect.TypeOf(x), reflect.TypeOf(&x)

    fmt.println(tx, tp, tx ==tp)
    fmt.Println(tx.kind(), tp.kind())
    fmt.Println(tx == tp.Elem())
}

输出:


int *int false
int ptr
true
  • 方法Elem返回指针,数据,切片,字典或通道的基类型。
func main()  {
    fmt.Println(reflect.TypeOf(map[string]int()).Elem())
    fmt.Println(reflect.TypeOf([]int32{}).Elem())
}

输出:

int
int32
  • 只有在获取结构体指针的基类型后,才能遍历它的字段。
type user struct {
    name string
    age  int
}

type manger struct {
    user
    title string
}

func main()  {
    var m manager
    t := reflect.TypeOf(&m)

    if t.kind() ==reflect.Ptr {
        t =t.Elem
    }

    for i := 0; i < t.NumField();i++ {
      f := t.Fiedle(i)
      fmt.Println(f.Name, f.Type, f.Offset)

      if f.Annoymous {
          for x := 0;x < f.Type.NumField();x++ {
              af := f.Type.Field(x)
              fmt.Println(" ", af.Name, af.Type)
          }
      }
    }
}

输出:

user main.user 0
   name string
   age  int
title string 24
  • 对于匿名字段,可用多级索引(按定义顺序)直接访问。
type user struct {
    name string
    age  int
}

type manager struct {
    user
    title string
}

func main()  {
    var m manager

    t := reflect.TypeOf(m)

    name, _ :=t.FieldByName("name")             //按照名称查找
    fmt.Println(name.Name, name.Type)

    age := t.FieldByIndex([]int{0, 1})           //按照多级索引查找
    fmt.Println(age.Name, age.Type)
}

输出:

name string
age  int
  • FieldByName 不支持多级名称,如有同名遮蔽,需通过匿名字段二次获取。

  • 同样的,输出方法集时,一样区分基类型和指针类型。

  • 有一点和想想的不用,反射能弹指当前包或外包的非导出结构成员。

  • 相对reflect来说,当前包和外包都是“外包”。

  • 可用反射提取struct tag ,还能自动分解,。常用于ORM映射,或数据格式验证。

  • 辅助判断方法 Implements ConvertibleTo AssignableTo,都是运行期进行动态调用和赋值所必须的。

9.2 值

和type获取类型信息不同value专注于对象实例数据读写。

接口变量会复制对象,且是unaddressable的,所以想修改目标对象,就必须使用指针。

func main()  {
    a := 100
    va, vp :=reflect.ValueOf(a), reflect.ValueOf(&a).Elem

    fmt.Println(va.CanAddr(), va.CanSet())
    fmt.Println(vp.CanAddr(), vp.CanSet())
}

输出:

false false
true  true
  • 就算传入指针,一样需要通过elem获取目标对象。因为被接口存储的指针本身是不能寻址和进行设置操作的。

  • 不能对非导出字段直接进行设置操纵,无论是当前包还是外包。

  • 可通过Interface 方法进行类型推断和转换。

  • 复合类型对象设置示例;

  • 接口有两种nil状态,这一直是个潜在麻烦。解决方法是用IsNil判断值是否为nil

  • 也可用unsafe转换后直接判断iface.data是否为零值。

  • value里的某些方法并未实现ok-idom或返回error,所以得自行判断返回的是否为Zero Value

9.3 方法

动态调用方法,谈不上有多麻烦。只需按In列表准备好所需参数即可。

type X struct {}

func (X) Test(x, y int) (int, error) {
    return x + y, fmt.Errorf("err:%d",x+y)
}

func main()  {
    var a X

    v := reflect.ValueOf(&a)
    m := v.MethodByName("TEST")

    in := []reflect.Value{
        reflect.ValueOf(1),
        reflect.ValueOf(2),
    }

    out := m.Call(in)
    for_, v := range out {
        fmt.Println(v)
    }
}

输出:

3
err: 3
  • 对于变参来说,用CallSlice要更方便一些。

9.4 构建

反射库提供了内置函数make和new的对应操作,其中最有意思的就是makefunc。可用它实现通过模板,适应不同数据类型。

//通用算法函数
func add(args []reflect.Value) (results []reflect.Value) {
    if len(args) == 0 {
        return nil
    }
    var ret reflect.Value

    switch args[0].Kind() {
    case reflect.Int:
        n := 0
        for_, a := range args {
            n += int(a, Int())
        }

      ret = reflect.ValueOf(n)
    case reflect.String:
      ss := make([]string, 0, len(args))
      for_, s := range args {
          ss = append(ss, s.String())
      }

      ret = reflect.ValueOf(strings.Join(ss, ""))
    }

    results = append(results, ret)
    return
}

//将函数指针参数指向通用算法函数
func makeAdd(fptr interface())  {
    fn := reflect.ValueOf(fptr).Elem()
    v := reflect.MakeFunc(fn, Type(), add())   //zheshi guanjian
    fn.Set(v)                                  //指向通用算法函数
}

func main()  {
    var int&Add func (x, y int) int
    var strAdd func(a, b string) string

    makeAdd(&intAdd)
    makeAdd(&strAdd)

    println(intAdd(100, 200))
    println(strAdd("hello,"," world!"))
}

输出:

300
hello, world!