Go Reflect 高級實踐

1. https://golang.org/pkg/reflect/ 最重要的官方文檔，建議先粗讀一遍再來看本文。
2. go 的 reflect 仍是比較簡單的，能夠很快上手。
3. https://github.com/golang/go/blob/master/src/reflect/type.go https://github.com/golang/go/blob/master/src/reflect/value.go
   源碼中有上百個 panic，各類檢查作的很全面，有想法就大膽地去試，只要能 run 起來，通常問題不大。
4. 實際使用中能夠先不考慮使用 reflect 對性能的影響，先實現功能，再利用 benchmark test 去優化

何時應該用 reflect

1. 爲了下降多寫代碼形成的bug率，作更好的歸約和抽象。
2. 爲了靈活、好用、方便，作動態解析、調用和處理。
3. 爲了代碼好看、易讀、提升開發效率，補足與動態語言之間的一些差異

記住！reflect 不是用來實現你的奇技淫巧的！使用 reflect 要適可而止！

reflect 核心

TypeOf(i interface{}) Type

重點看這個返回值，它是一個接口，主要實現它的是 struct rtype，這個也是 go 類型系統的核心，和 runtime/type.go struct _type 一致，這裏就不深刻展開了，回頭再說。

type Type interface {
    // 變量的內存對齊，返回 rtype.align
    Align() int

    // struct 字段的內存對齊，返回 rtype.fieldAlign
    FieldAlign() int

    // 根據傳入的 i，返回方法實例，表示類型的第 i 個方法
    Method(int) Method

    // 根據名字返回方法實例，這個比較經常使用
    MethodByName(string) (Method, bool)

    // 返回類型方法集中可導出的方法的數量
    NumMethod() int

    // 只返回類型名，不含包名
    Name() string

    // 返回導入路徑，即 import 路徑
    PkgPath() string

    // 返回 rtype.size 即類型大小，單位是字節數
    Size() uintptr

    // 返回類型名字，實際就是 PkgPath() + Name()
    String() string

    // 返回 rtype.kind，描述一種基礎類型
    Kind() Kind

    // 檢查當前類型有沒有實現接口 u
    Implements(u Type) bool

    // 檢查當前類型能不能賦值給接口 u
    AssignableTo(u Type) bool

    // 檢查當前類型能不能轉換成接口 u 類型
    ConvertibleTo(u Type) bool

    // 檢查當前類型能不能作比較運算，其實就是看這個類型底層有沒有綁定 typeAlg 的 equal 方法。
    // 打住！不要去搜 typeAlg 是什麼，否則你會陷進去的！先把本文看完。
    Comparable() bool

    // 返回類型的位大小，但不是全部類型都能調這個方法，不能調的會 panic
    Bits() int

    // 返回 channel 類型的方向，若是不是 channel，會 panic
    ChanDir() ChanDir

    // 返回函數類型的最後一個參數是否是可變數量的，"..." 就這樣的，一樣，若是不是函數類型，會 panic
    IsVariadic() bool

    // 返回所包含元素的類型，只有 Array, Chan, Map, Ptr, Slice 這些才能調，其餘類型會 panic。
    // 這不是廢話嗎。。其餘類型也沒有包含元素一說。
    Elem() Type

    // 返回 struct 類型的第 i 個字段，不是 struct 會 panic，i 越界也會 panic
    Field(i int) StructField

    // 跟上邊同樣，不過是嵌套調用的，好比 [1, 2] 就是說返回當前 struct 的第1個struct 的第2個字段，適用於 struct 自己嵌套的類型
    FieldByIndex(index []int) StructField

    // 按名字找 struct 字段，第二個返回值 ok 表示有沒有
    FieldByName(name string) (StructField, bool)

    // 按函數名找 struct 字段，由於 struct 裏也可能有類型是 func 的嘛
    FieldByNameFunc(match func(string) bool) (StructField, bool)
    
    // 返回函數第 i 個參數的類型，不是 func 會 panic
    In(i int) Type

    // 返回 map 的 key 的類型，不是 map 會 panic
    Key() Type

    // 返回 array 的長度，不是 array 會 panic
    Len() int

    // 返回 struct 字段數量，不是 struct 會 panic
    NumField() int

    // 返回函數的參數數量，不是 func 會 panic
    NumIn() int

    // 返回函數的返回值數量，不是 func 會 panic
    NumOut() int

    // 返回函數第 i 個返回值的類型，不是 func 會 panic
    Out(i int) Type
}

ValueOf(i interface{}) Value

先看看定義吧，就這麼點東西。

type Value struct {
    // 反射出來此值的類型，rtype 是啥往上看，但可別弄錯了，這 typ 是未導出的，從外部調不到 Type 接口的方法
    typ *rtype

    // 數據形式的指針值
    ptr unsafe.Pointer

    // 保存元數據
    flag
}

---

Value 的方法太多了，參考開頭的官方文檔吧，我下面挑幾個重點的說一下，像 len，cap 這種簡單的就不介紹了：

// 前提 v 是一個 func，而後調用 v，並傳入 in 參數，第一個參數是 in[0]，第二個是 in[1]，以此類推
func (v Value) Call(in []Value) []Value

// 返回 v 的接口值或者指針
func (v Value) Elem() Value

// 前提 v 是一個 struct，返回第 i 個字段，這個主要用於遍歷
func (v Value) Field(i int) Value

// 前提 v 是一個 struct，根據字段名直接定位返回
func (v Value) FieldByName(name string) Value

// 前提 v 是 Array, Slice, String 之一，返回第 i 個元素，主要也是用於遍歷，注意不能越界
func (v Value) Index(i int) Value

// 判斷 v 是否是 nil，只有 chan, func, interface, map, pointer, slice 能夠用，其餘類型會 panic
func (v Value) IsNil() bool

// 判斷 v 是否合法，若是返回 false，那麼除了 String() 之外的其餘方法調用都會 panic，事前檢查是必要的
func (v Value) IsValid() bool

// 前提 v 是個 map，返回對應 value
func (v Value) MapIndex(key Value)

// 前提 v 是個 map，返回全部 key 組成的一個 slice
func (v Value) MapKeys() []Value

// 前提 v 是個 struct，返回字段個數
func (v Value) NumField() int

// 賦值
func (v Value) Set(x Value)

// 類型
func (v Value) Type() Type

reflect 場景實踐

動態調用函數（無參數）

type T struct {}

func main() {
    name := "Do"
    t := &T{}
    reflect.ValueOf(t).MethodByName(name).Call(nil)
}

func (t *T) Do() {
    fmt.Println("hello")
}

動態調用函數（有參數）

type T struct{}

func main() {
    name := "Do"
    t := &T{}
    a := reflect.ValueOf(1111)
    b := reflect.ValueOf("world")
    in := []reflect.Value{a, b}
    reflect.ValueOf(t).MethodByName(name).Call(in)
}

func (t *T) Do(a int, b string) {
    fmt.Println("hello" + b, a)
}

處理返回值中的錯誤

返回值也是 Value 類型，對於錯誤，能夠轉爲 interface 以後斷言

type T struct{}

func main() {
    name := "Do"
    t := &T{}
    ret := reflect.ValueOf(t).MethodByName(name).Call(nil)
    fmt.Printf("strValue: %[1]v\nerrValue: %[2]v\nstrType: %[1]T\nerrType: %[2]T", ret[0], ret[1].Interface().(error))
}

func (t *T) Do() (string, error) {
    return "hello", errors.New("new error")
}

struct tag 解析

type T struct {
    A int    `json:"aaa" test:"testaaa"`
    B string `json:"bbb" test:"testbbb"`
}

func main() {
    t := T{
        A: 123,
        B: "hello",
    }
    tt := reflect.TypeOf(t)
    for i := 0; i < tt.NumField(); i++ {
        field := tt.Field(i)
        if json, ok := field.Tag.Lookup("json"); ok {
            fmt.Println(json)
        }
        test := field.Tag.Get("test")
        fmt.Println(test)
    }
}

類型轉換和賦值

type T struct {
    A int    `newT:"AA"`
    B string `newT:"BB"`
}

type newT struct {
    AA int
    BB string
}

func main() {
    t := T{
        A: 123,
        B: "hello",
    }
    tt := reflect.TypeOf(t)
    tv := reflect.ValueOf(t)

    newT := &newT{}
    newTValue := reflect.ValueOf(newT)

    for i := 0; i < tt.NumField(); i++ {
        field := tt.Field(i)
        newTTag := field.Tag.Get("newT")
        tValue := tv.Field(i)
        newTValue.Elem().FieldByName(newTTag).Set(tValue)
    }

    fmt.Println(newT)
}

經過 kind（）處理不一樣分支

func main() {
    a := 1
    t := reflect.TypeOf(a)
    switch t.Kind() {
    case reflect.Int:
        fmt.Println("int")
    case reflect.String:
        fmt.Println("string")
    }
}

判斷實例是否實現了某接口

type IT interface {
    test1()
}

type T struct {
    A string
}

func (t *T) test1() {}

func main() {
    t := &T{}
    ITF := reflect.TypeOf((*IT)(nil)).Elem()
    tv := reflect.TypeOf(t)
    fmt.Println(tv.Implements(ITF))
}

未完待續

...