網站首頁編程語言正文

Golang中反射的常見用法分享_Golang

作者：rubys_ ? 更新時間： 2023-02-12 編程語言

在之前的兩篇文章《深入理解 go reflect - 反射基本原理》、《深入理解 go reflect - 要不要傳指針》中，我們講解了關于 go 反射的一些基本原理，以及通過反射對象修改變量的一些注意事項。本篇文章將介紹一些常見的反射用法，涵蓋了常見的數據類型的反射操作。

根據類型做不同處理

使用反射很常見的一個場景就是根據類型做不同處理，比如下面這個方法，根據不同的 Kind 返回不同的字符串表示：

func getType(i interface{}) string {
   v := reflect.ValueOf(i)

   switch v.Kind() {
   case reflect.Bool:
      b := "false"
      if v.Bool() {
         b = "true"
      }
      return fmt.Sprintf("bool: %s", b)
   case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
      return fmt.Sprintf("int: %d", v.Int())
   case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
      return fmt.Sprintf("uint: %d", v.Uint())
   case reflect.Float32, reflect.Float64:
      return fmt.Sprintf("float: %.1f", v.Float())
   case reflect.String:
      return fmt.Sprintf("string: %s", v.String())
   case reflect.Interface:
      return fmt.Sprintf("interface: %v", v.Interface())
   case reflect.Struct:
      return fmt.Sprintf("struct: %v", v.Interface())
   case reflect.Map:
      return fmt.Sprintf("map: %v", v.Interface())
   case reflect.Slice:
      return fmt.Sprintf("slice: %v", v.Interface())
   case reflect.Array:
      return fmt.Sprintf("array: %v", v.Interface())
   case reflect.Pointer:
      return fmt.Sprintf("pointer: %v", v.Interface())
   case reflect.Chan:
      return fmt.Sprintf("chan: %v", v.Interface())
   default:
      return "unknown"
   }
}

func TestKind(t *testing.T) {
   assert.Equal(t, "int: 1", getType(1))
   assert.Equal(t, "string: 1", getType("1"))
   assert.Equal(t, "bool: true", getType(true))
   assert.Equal(t, "float: 1.0", getType(1.0))

    arr := [3]int{1, 2, 3}
    sli := []int{1, 2, 3}
    assert.Equal(t, "array: [1 2 3]", getType(arr))
    assert.Equal(t, "slice: [1 2 3]", getType(sli))
}

標準庫 json 中的示例

在標準庫 encoding/json 中，也有類似的場景，比如下面這個方法，根據不同的 Kind 做不同的處理：

func newTypeEncoder(t reflect.Type, allowAddr bool) encoderFunc {
   // ... 其他代碼
   switch t.Kind() {
   case reflect.Bool:
      return boolEncoder
   case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
      return intEncoder
   case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
      return uintEncoder
   // ...省略其他 case...
   default:
      return unsupportedTypeEncoder
   }
}

在進行 json 編碼的時候，因為不知道傳入的參數是什么類型，所以需要根據類型做不同的處理，這里就是使用反射來做的。通過判斷不同的類型，然后返回不同的 encoder。

基本類型的反射

這里說的基本類型是：int*、uint*、float*、complex*、bool 這種類型。

通過反射修改基本類型的值，需要注意的是，傳入的參數必須是指針類型，否則會 panic：

func TestBaseKind(t *testing.T) {
   // 通過反射修改 int 類型變量的值
   a := 1
   v := reflect.ValueOf(&a)
   v.Elem().SetInt(10)
   assert.Equal(t, 10, a)

   // 通過反射修改 uint16 類型變量的值
   b := uint16(10)
   v1 := reflect.ValueOf(&b)
   v1.Elem().SetUint(20)
   assert.Equal(t, uint16(20), b)

   // 通過反射修改 float32 類型變量的值
   f := float32(10.0)
   v2 := reflect.ValueOf(&f)
   v2.Elem().SetFloat(20.0)
   assert.Equal(t, float32(20.0), f)
}

通過反射修改值的時候，需要通過 Elem() 方法的返回值來修改。

數組類型的反射

通過反射修改數組中元素的值，可以使用 Index 方法取得對應下標的元素，然后再使用 Set 方法修改值：

func TestArray(t *testing.T) {
   // 通過反射修改數組元素的值
   arr := [3]int{1, 2, 3}
   v := reflect.ValueOf(&arr)
   // 修改數組中的第一個元素
   v.Elem().Index(0).SetInt(10)
   assert.Equal(t, [3]int{10, 2, 3}, arr)
}

chan 反射

我們可以通過反射對象來向 chan 中發送數據，也可以從 chan 中接收數據：

func TestChan(t *testing.T) {
   // 通過反射修改 chan
   ch := make(chan int, 1)
   v := reflect.ValueOf(&ch)
   // 通過反射對象向 chan 發送數據
   v.Elem().Send(reflect.ValueOf(2))
   // 在反射對象外部從 chan 接收數據
   assert.Equal(t, 2, <-ch)
}

map 反射

通過反射修改 map 中的值，可以使用 SetMapIndex 方法修改 map 中對應的 key：

func TestMap(t *testing.T) {
   // 通過反射修改 map 元素的值
   m := map[string]int{"a": 1}
   v := reflect.ValueOf(&m)
   // 修改 a 的 key，修改其值為 2
   v.Elem().SetMapIndex(reflect.ValueOf("a"), reflect.ValueOf(2))
   // 外部的 m 可以看到反射對象的修改
   assert.Equal(t, 2, m["a"])
}

迭代反射 map 對象

我們可以通過反射對象的 MapRange 方法來迭代 map 對象：

func TestIterateMap(t *testing.T) {
   // 遍歷 map
   m := map[string]int{"a": 1, "b": 2}
   v := reflect.ValueOf(m)
   // 創建 map 迭代器
   iter := v.MapRange()

   // 迭代 map 的元素
   for iter.Next() {
      // a 1
      // b 2
      fmt.Println(iter.Key(), iter.Value())
   }
}

slice 反射

通過反射修改 slice 中的值，可以使用 Index 方法取得對應下標的元素，然后再使用 Set* 方法修改值，跟數組類似：

func TestSlice(t *testing.T) {
   // 通過反射修改 slice 元素的值
   sli := []int{1, 2, 3}
   v := reflect.ValueOf(&sli)
   v.Elem().Index(0).SetInt(10)
   assert.Equal(t, []int{10, 2, 3}, sli)
}

string 反射

對于 string 類型，我們可以通過其反射對象的 String 方法來修改其內容：

func TestString(t *testing.T) {
   // 通過反射修改字符串的值
   s := "hello"
   v := reflect.ValueOf(&s)
   v.Elem().SetString("world")
   assert.Equal(t, "world", s)
}

interface/Pointer 反射

對于 interface 或 Pointer 類型，我們可以通過其反射對象的 Elem 方法來修改其內容：

func TestPointer(t *testing.T) {
   a := 1

   // 接口類型
   var i interface{} = &a
   v1 := reflect.ValueOf(i)
   v1.Elem().SetInt(10)
   assert.Equal(t, 10, a)

   // 指針類型
   var p = &a
   v2 := reflect.ValueOf(p)
   v2.Elem().SetInt(20)
   assert.Equal(t, 20, a)
}

這兩種類型，我們都需要通過 Elem 方法來先獲取其實際保存的值，然后再修改其值。

結構體的反射

對于 go 中的結構體，反射系統中為我們提供了很多操作結構體的方法，比如獲取結構體的字段、方法、標簽、通過反射對象調用其方法等。

先假設我們有如下結構體：

type Person struct {
   Name string
   Age  int

   sex uint8
}

func (p Person) M1() string {
   return "person m1"
}

func (p *Person) M2() string {
   return "person m2"
}

遍歷結構體字段

我們可以通過 NumField 方法來獲取結構體的字段數量，然后通過 Field 方法來獲取結構體的字段：

func TestStruct1(t *testing.T) {
   var p = Person{Name: "Tom", Age: 18, sex: 1}
   v := reflect.ValueOf(p)

   // string Tom
   // int 18
   // uint8 1
   for i := 0; i < v.NumField(); i++ {
      fmt.Println(v.Field(i).Type(), v.Field(i))
   }
}

根據名稱或索引獲取結構體字段

我們可以根據結構體字段的名稱或索引來獲取結構體的字段：

func TestStruct2(t *testing.T) {
   var p = Person{Name: "Tom", Age: 18, sex: 1}
   v := reflect.ValueOf(p)

   assert.Equal(t, 18, v.Field(1).Interface())
   assert.Equal(t, 18, v.FieldByName("Age").Interface())
   assert.Equal(t, 18, v.FieldByIndex([]int{1}).Interface())
}

修改結構體字段

我們可以通過 Field 方法來獲取結構體的字段，然后再使用 Set* 方法來修改其值：

func TestStruct2(t *testing.T) {
   var p = Person{Name: "Tom", Age: 18, sex: 1}
   v := reflect.ValueOf(&p)

   v.Elem().FieldByName("Name").SetString("Jack")

   assert.Equal(t, "Jack", p.Name)
}

上面因為 Name 是 string 類型，所以我們使用 SetString 方法來修改其值，如果是 int 類型，我們可以使用 SetInt 方法來修改其值，依此類推。

結構體方法調用

通過反射對象來調用結構體的方法時，需要注意的是，如果我們需要調用指針接收者的方法，則需要傳遞地址：

func TestStruct3(t *testing.T) {
   var p = Person{Name: "Tom", Age: 18, sex: 1}

   // 值接收者（receiver）
   v1 := reflect.ValueOf(p)
   assert.Equal(t, 1, v1.NumMethod())
   // 注意：值接收者沒有 M2 方法
   assert.False(t, v1.MethodByName("M2").IsValid())

   // 通過值接收者調用 M1 方法
   results := v1.MethodByName("M1").Call(nil)
   assert.Len(t, results, 1)
   assert.Equal(t, "person m1", results[0].Interface())

   // 指針接收者（pointer receiver）
   v2 := reflect.ValueOf(&p)
   assert.Equal(t, 2, v2.NumMethod())

   // 通過指針接收者調用 M1 和 M2 方法
   results = v2.MethodByName("M1").Call(nil)
   assert.Len(t, results, 1)
   assert.Equal(t, "person m1", results[0].Interface())

   results = v2.MethodByName("M2").Call(nil)
   assert.Len(t, results, 1)
   assert.Equal(t, "person m2", results[0].Interface())
}

說明：

結構體參數是值的時候，reflect.ValueOf 返回的反射對象只能調用值接收者的方法，不能調用指針接收者的方法。
結構體參數是指針的時候，reflect.ValueOf 返回的反射對象可以調用值接收者和指針接收者的方法。
調用 MethodByName 方法時，如果方法不存在，則返回的反射對象的 IsValid 方法返回 false。
調用 Call 方法時，如果沒有參數，傳 nil 參數即可。如果方法沒有返回值，則返回的結果切片為空。
調用 Call 方法的參數是 reflect.Value 類型的切片，返回值也是 reflect.Value 類型的切片。

是否實現接口

對于這個，其實有一個更簡單的方法，那就是利用接口斷言：

func TestStrunct4_0(t *testing.T) {
   type TestInterface interface {
      M1() string
   }

   var p = Person{Name: "Tom", Age: 18, sex: 1}
   v := reflect.ValueOf(p)

   // v.Interface() 返回的是 interface{} 類型
   // v.Interface().(TestInterface) 將 interface{} 類型轉換為 TestInterface 類型
   v1, ok := v.Interface().(TestInterface)
   assert.True(t, ok)
   assert.Equal(t, "person m1", v1.M1())
}

另外一個方法是，通過反射對象的 Type 方法獲取類型對象，然后調用 Implements 方法來判斷是否實現了某個接口：

func TestStruct4(t *testing.T) {
   type TestInterface interface {
      M1() string
   }

   var p = Person{Name: "Tom", Age: 18, sex: 1}
   typ := reflect.TypeOf(p)

   typ1 := reflect.TypeOf((*TestInterface)(nil)).Elem()
   assert.True(t, typ.Implements(typ1))
}

結構體的 tag

這在序列化、反序列化、ORM 庫中用得非常多，常見的 validator 庫也是通過 tag 來實現的。下面的例子中，通過獲取變量的 Type 就可以獲取其 tag 了：

type Person1 struct {
   Name string `json:"name"`
}

func TestStruct5(t *testing.T) {
   var p = Person1{Name: "Tom"}
   typ := reflect.TypeOf(p)
   tag := typ.Field(0).Tag

   assert.Equal(t, "name", tag.Get("json"))
}

修改結構體未導字段

我們知道，結構體的字段如果首字母小寫，則是未導出的，不能被外部包訪問。但是我們可以通過反射修改它：

func TestStruct6(t *testing.T) {
   var p = Person{Name: "Tom", Age: 18, sex: 1}
   v := reflect.ValueOf(&p)

   // 下面這樣寫會報錯：
   // panic: reflect: reflect.Value.SetInt using value obtained using unexported field
   // v.Elem().FieldByName("sex").SetInt(0)
   ft := v.Elem().FieldByName("sex")

   sexV := reflect.NewAt(ft.Type(), unsafe.Pointer(ft.UnsafeAddr())).Elem()

   assert.Equal(t, 1, p.sex)           // 修改前是 1
   sexV.Set(reflect.ValueOf(uint8(0))) // 將 sex 字段修改為 0
   assert.Equal(t, 0, p.sex)           // 修改后是 0
}

這里通過 NewAt 方法針對 sex 這個未導出的字段創建了一個指針，然后我們就可以通過這個指針來修改 sex 字段了。

方法的反射

這里說的方法包括函數和結構體的方法。

入參和返回值

reflect 包中提供了 In 和 Out 方法來獲取方法的入參和返回值：

func (p Person) Test(a int, b string) int {
   return a
}

func TestMethod(t *testing.T) {
   var p = Person{Name: "Tom", Age: 18, sex: 1}
   v := reflect.ValueOf(p)

   m := v.MethodByName("Test")
   // 參數個數為 2
   assert.Equal(t, 2, m.Type().NumIn())
   // 返回值個數為 1
   assert.Equal(t, 1, m.Type().NumOut())

   // In(0) 是第一個參數，In(1) 是第二個參數
   arg1 := m.Type().In(0)
   assert.Equal(t, "int", arg1.Name())
   arg2 := m.Type().In(1)
   assert.Equal(t, "string", arg2.Name())

   // Out(0) 是第一個返回值
   ret0 := m.Type().Out(0)
   assert.Equal(t, "int", ret0.Name())
}

說明：

In 和 Out 方法返回的是 reflect.Type 類型，可以通過 Name 方法獲取類型名稱。
NumIn 和 NumOut 方法返回的是參數和返回值的個數。
reflect.Value 類型的 MethodByName 方法可以獲取結構體的方法。

通過反射調用方法

reflect.Value 中對于方法類型的反射對象，有一個 Call 方法，可以通過它來調用方法：

func TestMethod2(t *testing.T) {
   var p = Person{Name: "Tom", Age: 18, sex: 1}
   v := reflect.ValueOf(p)

   // 通過反射調用 Test 方法
   m := v.MethodByName("Test")
   arg1 := reflect.ValueOf(1)
   arg2 := reflect.ValueOf("hello")
   args := []reflect.Value{arg1, arg2}

   rets := m.Call(args)
   assert.Len(t, rets, 1)
   assert.Equal(t, 1, rets[0].Interface())
}

說明：

Call 方法的參數是 []reflect.Value 類型，需要將參數轉換為 reflect.Value 類型。
Call 方法的返回值也是 []reflect.Value 類型。
reflect.Value 類型的 MethodByName 方法可以獲取結構體的方法的反射對象。
通過方法的反射對象的 Call 方法可以實現調用方法。

總結

通過 reflect.Kind 可以判斷反射對象的類型，Kind 涵蓋了 go 中所有的基本類型，所以反射的時候判斷 Kind 就足夠了。
如果要獲取反射對象的值，需要傳遞指針給 reflect.Value。
可以往 chan 的反射對象中發送數據，也可以從 chan 的反射對象中接收數據。
SetMapIndex 方法可以修改 map 中的元素。MapRange 方法可以獲取 map 的迭代器。
可以通過 Index 方法獲取 slice 的元素，也可以通過 SetIndex 方法修改 slice 的元素。
可以通過 SetString 方法修改 string 的值。
對于 interface 和 Pointer 類型的反射對象，可以通過 Elem 方法獲取它們的值，同時也只有通過 Elem 獲取到的反射對象能調用 Set* 方法來修改其指向的對象。
reflect 包中提供了很多操作結構體的功能：如獲取結構體的字段、獲取結構體的方法、調用結構體的方法等。我們使用一些類庫的時候，會需要通過結構體的 tag 來設置一些元信息，這些信息只有通過反射才能獲取。
我們可以通過 NewAt 來創建一個指向結構體未導出字段的反射對象，這樣就可以修改結構體的未導出字段了。
對于函數和方法，go 的反射系統也提供了很多功能，如獲取參數和返回值信息、使用 Call 來調用函數和方法等。

原文鏈接：https://mp.weixin.qq.com/s/77sumc5748jrCOTf7STFWw

上一篇：深入了解Golang中reflect反射基本原理_Golan
下一篇：Golang反射模塊reflect使用方式示例詳解_Gola

日本免费高清视频-国产福利视频导航-黄色在线播放国产-天天操天天操天天操天天操|www.shdianci.com

網站首頁編程語言正文

Golang中反射的常見用法分享_Golang

目錄

根據類型做不同處理

標準庫 json 中的示例

基本類型的反射

數組類型的反射

chan 反射

map 反射

迭代反射 map 對象

slice 反射

string 反射

interface/Pointer 反射

結構體的反射

遍歷結構體字段

根據名稱或索引獲取結構體字段

修改結構體字段

結構體方法調用

是否實現接口

結構體的 tag

修改結構體未導字段

方法的反射

入參和返回值

通過反射調用方法

總結

相關推薦

日本免费高清视频-国产福利视频导航-黄色在线播放国产-天天操天天操天天操天天操|www.shdianci.com

網站首頁 編程語言 正文

Golang中反射的常見用法分享_Golang

目錄

根據類型做不同處理

標準庫 json 中的示例

基本類型的反射

數組類型的反射

chan 反射

map 反射

迭代反射 map 對象

slice 反射

string 反射

interface/Pointer 反射

結構體的反射

遍歷結構體字段

根據名稱或索引獲取結構體字段

修改結構體字段

結構體方法調用

是否實現接口

結構體的 tag

修改結構體未導字段

方法的反射

入參和返回值

通過反射調用方法

總結

相關推薦

網站首頁編程語言正文