《Go语言学习笔记》读书笔记(2)反射

反射

反射能让我们能在运行期探知对象的类型信息和内存结构，同时反射还是实现元编程的重要手段。
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
}

func main() {
  a := reflect.ArrayOf(10, reflect.TypeOf(byte(0)))
  b := reflect.MapOf(reflect.TypeOf(""), reflect.TypeOf(0))
  fmt.Println(a, m)
  /// 输出: [10]uint8 map[string]int
}

方法Elem返回指针、数组、切片、字典值或通道的基类型。

func main() {
  fmt.Println(reflect.TypeOf(map[string]int{}).Elem())
  fmt.Println(reflect.TypeOf([]int32{}).Elem())
  /// 输出： int int32
}

只有在获取结构体指针的基类型后，才能遍历它的字段。

 package main

import (
	"fmt"
	"reflect"
)

type user struct {
	name string
	age int
}

type manager 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.Field(i)
		fmt.Println(f.Name, f.Type, f.Offset)
		if f.Anonymous {
			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

对于匿名字段，可用多级索引（按定义顺序）直接访问

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不支持多级名称，如有同名遮蔽，须通过匿名字段二次获取

反射能探知当前包或外包的非导出结构成员

package main

import (
	"fmt"
	"net/http"
	"reflect"
)

func main() {
	var s http.Server
	t := reflect.TypeOf(s)
	for i := 0; i < t.NumField(); i++ {
		fmt.Println(t.Field(i).Name)
	}
}

/// 输出：
/// Addr
/// Handler
/// TLSConfig
/// ReadTimeout
/// ReadHeaderTimeout
/// WriteTimeout
/// IdleTimeout
/// MaxHeaderBytes
/// TLSNextProto
/// ConnState
/// ErrorLog
/// BaseContext
/// ConnContext
/// inShutdown
/// disableKeepAlives
/// nextProtoOnce
/// nextProtoErr
/// mu
/// listeners
/// activeConn
/// doneChan
/// onShutdown

相对reflect而言，当前包和外包都是”外包”

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

type user struct {
	name string `field:"name" type:"varchar(50)"`
	age int	`field:"age" type:"int"`
}

func main() {
	var u user
	t := reflect.TypeOf(u)
	for i := 0; i < t.NumField(); i++ {
		f := t.Field(i)
		fmt.Printf("%s: %s %s\n", f.Name, f.Tag.Get("field"), f.Tag.Get("type"))
	}
}

/// 输出：
/// name: name varchar(50)
/// age: age int

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

type X int

func (X) String() string {
	return ""
}

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

	// Implements 不能直接使用类型作为参数，导致这种用法特别别扭
	st := reflect.TypeOf((*fmt.Stringer)(nil)).Elem()
	fmt.Println(t.Implements(st))

	it := reflect.TypeOf(0)
	fmt.Println(t.ConvertibleTo(it))

	fmt.Println(t.AssignableTo(st), t.AssignableTo(it))
}
/// 输出：
/// true
/// true
/// true false

值

和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.CpnAddr(), va.CanSet())
}
/// 输出:
/// false false
/// true true

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

注意：不能对非导出字段进行设置操作，无论是当前包还是外包。

type User struct {
	Name string
	code int
}

func main() {
	p := new(User)
	v := reflect.ValueOf(p).Elem()
	name := v.FieldByName("Name")
	code := v.FieldByName("code")

	fmt.Printf("name: canaddr = %v, canset = %v\n", name.CanAddr(), name.CanSet())
	fmt.Printf("code: canaddr = %v, canset = %v\n", code.CanAddr(), code.CanSet())

	if name.CanSet() {
		name.SetString("Tom")
	}
	if code.CanAddr() {
		*(*int)(unsafe.Pointer(code.UnsafeAddr())) = 100
  }
  fmt.Printf("%+v\n", *p)
}
/// 输出：
/// name: canaddr = true, canset = true
/// code: canaddr = true, canset = false
/// {Name:Tom code:100}

Value.Pointer和Value.Int等方法类似，将Value.data存储的数据转换为指针，目标必须是指针类型。
而UnsafeAddr返回任何CanAddr Value.data地址（相当于&取地址操作）,比如Elem后的Value, 以及字段成员地址。
以结构体里的指针类型字段为例，Pointer返回该字段所保存的地址，而UnsafeAddr返回该字段本身的地址(结构对象地址+偏移量)

可通过Interface方法进行类型推断

func main() {
	type user struct {
		Name string
		Age int
	}

	u := user{
		"q.yuhen",
		60,
	}

	v := reflect.ValueOf(&u)
	if !v.CanInterface() {
		println("CanInterface: fail.")
		return
	}

	p, ok := v.Interface().(*user)
	if !ok {
		println("Interface: fail.")
		return
	}

	p.Age++
	fmt.Printf("%+v\n", u)
}
/// 输出：
/// {Name:q.yuhen Age:61}

也可以直接使用Value.Int、Bool等方法进行类型转换，但失败时会引发panic, 且不支持ok-idiom

复合类型对象设置示例：

func main() {
  c := make(chan int, 4)
  v := reflect.ValueOf(c)

  if v.TrySend(reflect.ValueOf(100)) {
    fmt.Println(v.TryRecv())
  }
}
/// 100 true

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

func main() {
  var a interface{} = nil
  var b interface{} = (*int)(nil)

  fmt.Println(a == nil)
  fmt.Println(b == nil, reflect.ValueOf(b).IsNil())
}
/// 输出：
/// true
/// false true

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

func main() {
  var b interface{} = (*int)(nil)
  iface := (*[2]uintptr)(unsafe.Pointer(&b))
  fmt.Println(iface, iface[1] == 0)
}

/// 输出:
/// &[712160 0] true

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

func main(){
  v := reflect.ValueOf(struct{name string})
  println(v.FieldByName("name").IsValid())
  println(v.FieldByName("xxx").IsValid())
}
/// 输出：
/// true
/// false

方法

动态调用方法，谈不上有多麻烦。只须按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 := 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要更方便一些

type X struct {}
 func (X) Format(s string, a ...interface{}) string {
   return fmt.Sprintf(s, a...)
 }

 func main() {
   var a X
   v := reflect.ValueOf(&a)
   m := v.MethodByName("Format")
   out := m.Call([]reflect.Value{
     reflect.ValueOf("%s = %d"),
     reflect.ValueOf("x"),
     reflect.ValueOf("100"),
   })

   fmt.Println(out)

   out = m.CallSlice([]reflect.ValueP{
     reflect.ValueOf("%s = %d"),
     reflect.ValueOf([]interface{}{"x", 100}),
   })

   fmt.Println(out)
 }
/// 输出：
/// [x = 100]
/// [x = 100]

构建

反射库提供了内置函数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) // 这是关键
  fn.Set(v) // 指向通用算法函数
}

func main () {
  var intAdd func(s, 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!