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 可以用，其他類型會 panicfunc (v Value) IsNil() bool// 判斷 v 是否合法，如果返回 false，那麼除了 String() 以外的其他方法調用都會 panic，事前檢查是必要的func (v Value) IsValid() bool// 前提 v 是個 map，返回對應 valuefunc (v Value) MapIndex(key Value)// 前提 v 是個 map，返回所有 key 組成的一個 slicefunc (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))}

未完待續

...