Go語言學習筆記之反射用法詳解

2020-04-01 19:05:32

字體：大中小

來源：轉載

供稿：網友

本文實例講述了Go學習筆記之反射用法。分享給大家供大家參考，具體如下：

一、類型(Type)

反射（reflect）讓我們能在運行期探知對象的類型信息和內存結構，這從一定程度上彌(mi)補了靜態語言在動態行為上的不足。同時，反射還是實現元編程的重要手段。

和 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)
	    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())
	}

除通過實際對象獲取類型外，也可直接構造一些基礎復合類型。

復制代碼代碼如下:

	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 := 100
	    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 falseint ptrtrue

方法 Elem() 返回指針、數組、切片、字典（值）或通道的基類型。

復制代碼代碼如下:

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

輸出：

intint32

只有在獲取結構體指針的基類型后，才能遍歷它的字段。

復制代碼代碼如下:

	
	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 inttitle 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 stringage int

FieldByName() 不支持多級名稱，如有同名遮蔽，須通過匿名字段二次獲取。

同樣地，輸出方法集時，一樣區分基類型和指針類型。

復制代碼代碼如下:

	type A int
	type B struct {
	    A
	}
	func (A) av() {}
	func (*A) ap() {}
	func (B) bv() {}
	func (*B) bp() {}
	func main() {
	    var b B
	    t := reflect.TypeOf(&b)
	    s := []reflect.Type{t, t.Elem()}
	    for _, t2 := range s {
	        fmt.Println(t2, ":")
	        for i := 0; i < t2.NumMethod(); i++ {
	            fmt.Println(" ", t2.Method(i))
	        }
	    }
	}

輸出：

*main.B :  {ap main func(*main.B) <func(*main.B) Value> 0}  {av main func(*main.B) <func(*main.B) Value> 1}  {bp main func(*main.B) <func(*main.B) Value> 2}  {bv main func(*main.B) <func(*main.B) Value> 3}   main.B :  {av main func(*main.B) <func(*main.B) Value> 0}   {bv main func(*main.B) <func(*main.B) Value> 1}

有一點和想象的不同，反射能探知當前包或外包的非導出結構成員。

復制代碼代碼如下:

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

輸出：

AddrHandlerReadTimeoutWriteTimeoutTLSConfigMaxHeaderBytesTLSNextProtoConnStateErrorLogdisableKeepAlivesnextProtoOncenextProtoErr

相對 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))
	}

輸出：

truetruetrue false

二、值(Value)

和 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 falsetrue 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 = truecode: 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 等方法進行類型轉換，但失敗時會引發 pani，且不支持 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())
	}

輸出：

truefalse 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())
	}

輸出：

truefalse

三、方法

動態調用方法，談不上有多麻煩。只須按 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)
	    }
	}

輸出：

3err: 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.Value{
	        reflect.ValueOf("%s = %d"),
	        reflect.ValueOf([]interface{}{"x", 100}),
	    })
	    fmt.Println(out)
	}

輸出：

[x = 100][x = 100]

無法調用非導出方法，甚至無法獲取有效地址。

四、構建

反射庫提供了內置函數 make() 和 new() 的對應操作，其中最有意思的就是 MakeFunc()?？捎盟鼘崿F通用模板，適應不同數據類型。

復制代碼代碼如下:

	// 通用算法函數
	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(x, y int) int
	    var strAdd func(a, b string) string
	    makeAdd(&intAdd)
	    makeAdd(&strAdd)
	    println(intAdd(100, 200))
	    println(strAdd("hello, ", "world!"))
	}