Golang語言學(xué)習(xí)拿捏Go反射示例教程

新用戶604881da 2021-11-09

展開全文

1. 反射簡介

1.1 反射是什么？

Go語言提供了一種機制在運行時更新和檢查變量的值、調(diào)用變量的方法和變量支持的內(nèi)在操作，但是在編譯時并不知道這些變量的具體類型，這種機制被稱為反射。反射也可以讓我們將類型本身作為第一類的值類型處理。

反射是指在程序運行期對程序本身進行訪問和修改的能力，程序在編譯時變量被轉(zhuǎn)換為內(nèi)存地址，變量名不會被編譯器寫入到可執(zhí)行部分，在運行程序時程序無法獲取自身的信息。

舉個例子
平時我們定義變量都是正射

1	`var a int`

將變量a定義成一個int類型

現(xiàn)在我并不知道變量a是什么類型，但是我可以通過反射也知曉變量a是什么來歷！是什么類型！

type FanOne struct {

name string

}

func main(){

var a int = 1

var d FanOne

fmt.Println(reflect.TypeOf(a)) // int

// 這里就拿到了a的類型！注意是類型！不是類別！雖然這個類型和類別是一樣的

// 后面會說說類型(Type)和類別(Kind)的區(qū)別

fmt.Println(reflect.ValueOf(a).Kind()) //int

//這樣就拿到了a的類別，是通過a的值來判斷類別

fmt.Println(reflect.TypeOf(d)) //main.FanOne

//類型是main.FanOne 是在main里面定義的FanOne

fmt.Println(reflect.ValueOf(d).Kind()) //struct

//類別是struct

// 輸出 d 的類型名稱和種類，類型名稱就是 FanOne

//而 FanOne 屬于一種結(jié)構(gòu)體類別，因此類別為 struct

}

所以這個類別和類型有時候相同，有時候不同。

1.2 為什么需要反射？

在開發(fā)當中，當我們對于某一個函數(shù)進行值的處理的時候，但是為了保證這個函數(shù)能接受更多類型的值，因為go是強類型的語言，雖然interface可以接受所有的數(shù)據(jù)類型，但是在處理數(shù)據(jù)的時候，要對不同類型進行不同的處理的時候就會顯得代碼十分冗余，于是我們可以使用反射來進行對傳入?yún)?shù)的判斷與處理。

詳細見例題

2. reflect包

2.1 基本反射

reflect.TypeOf() //獲取變量的類型，返回reflect.Type類型

reflect.ValueOf() //獲取變量的值，返回reflect.Value類型

reflect.Value.Kind() //獲取變量的類別，返回一個常量

reflect.Value.Interface() //轉(zhuǎn)換成interface{}類型

2.2 反射與指針

Go語言程序中對指針獲取反射對象時，可以通過 reflect.Elem() 方法獲取這個指針指向的元素類型，這個獲取過程被稱為取元素，等效于對指針類型變量做了一個*操作

1	`reflect.ValueOf(xxx).Elem()`

2.3 反射與對象

可以通過reflect.new(xxx)或是reflect.zero(xxx)來進行反射，創(chuàng)建原始類型的對象

func CreatePrimitiveObjects(t reflect.Type) reflect.Value {

return reflect.Zero(t)

}

也可以使用

1	`reflect.New()`

來進行創(chuàng)建原始對象。

2.4 反射與函數(shù)

如果反射值對象（reflect.Value）中值的類型為函數(shù)時，可以通過reflect.Value調(diào)用該函數(shù)。使用反射調(diào)用函數(shù)時，需要將參數(shù)使用反射值對象的切片[]reflect.Value構(gòu)造后傳入Call()方法中，調(diào)用完成時，函數(shù)的返回值通過[]reflect.Value返回。
在反射中函數(shù) 和方法的類型（Type）都是reflect.Func，如果要調(diào)用函數(shù)的話，可以通過 Value 的 Call() 方法，例如：

package main

import (

"fmt"

"reflect"

)

func FanOne() string {

return "一鍵三連"

}

func FanOneWoW(a string) string {

return fmt.Sprintf("%s要給FanOne一鍵三連噢~",a)

}

func main() {

FanOneNotArgs := reflect.ValueOf(FanOne).Call([]reflect.Value{}) //無參數(shù)

FanOneHaveArgs := reflect.ValueOf(FanOneWoW).Call([]reflect.Value{reflect.ValueOf("我")}) //有參數(shù)

fmt.Println(FanOneNotArgs[0])

fmt.Println(FanOneHaveArgs[0])

}

2.5 反射例子

填寫fn函數(shù)使得輸出為

要求不使用任何的switch 或是 if 或是其他選擇語句。

func fn(callback interface{}, bytes []byte) {

//coding

}

type aaa struct {

Name string `json:"name"`

Age int `json:"age"`

}

func Test(t *testing.T) {

fn(func(a []*aaa) string {

aaas := a

for i, item := range aaas {

fmt.Println(i, item)

}

fmt.Println("12312312, ", aaas)

return "xxxx"

}, []byte("[{\"name\":\"111\",\"age\":1}, {\"name\":\"gsjk\",\"age\":2}]"))

fn(func(a []aaa) string {

aaas := a

for i, item := range aaas {

fmt.Println(i, item)

}

fmt.Println("12312312, ", aaas[0])

return "xxxx"

}, []byte("[{\"name\":\"111\",\"age\":1}, {\"name\":\"gsjk\",\"age\":2}]"))

fn(func(a *aaa) string {

fmt.Println("12312312, ", a)

aaas := a

fmt.Println("12312312, ", aaas)

return "xxxx"

}, []byte("{\"name\":\"gsjk\",\"age\":2}"))

fn(func(a string) string {

fmt.Println("12312312, ", a)

aaas := a

fmt.Println("12312312, ", aaas)

return "xxxx"

}, []byte("\"sss\""))

fn(func(a int) string {

fmt.Println("-----------, ", a)

aaas := a

fmt.Println("-----------, ", aaas)

return "xxxx"

}, []byte("123"))

}

（1）首先是test的知識：
名稱一定要有_test，不然好像會報錯，我就是這樣。

1 2	`go test xxx_test.go` `go test -v xxx_test.go`

（2）其次是了解這個fn()里面的匿名函數(shù)
單獨拿出來

func(a []*aaa) string {

aaas := a

for i, item := range aaas {

fmt.Println(i, item)

}

fmt.Println("12312312, ", aaas)

return "xxxx"

}, []byte("[{\"name\":\"111\",\"age\":1}, {\"name\":\"gsjk\",\"age\":2}]"))

可以看到這是一個*aaa類型的數(shù)組。那么我們?nèi)蝿?wù)就是反射出fn這個函數(shù)里面的匿名函數(shù)，然后調(diào)用反射出來的這個匿名函數(shù)，并將參數(shù)傳入其中。

以下都是用第一個作為例子

（3）那么我們先ValueOf和TypeOf這個interface{}，然后再看這個匿名函數(shù)各種的值

func fn(callback interface{}, bytes []byte) {

v := reflect.ValueOf(callback) //0xbaff40

t := reflect.TypeOf(callback) //func([]*main.aaa) string

}

我們可以看到入?yún)⒌暮瘮?shù)的Type是func([]*main.aaa) string 所以我們可以用

1	`paramsValue := t.In(0) //[]*main.aaa`

拿到匿名函數(shù)的傳入?yún)?shù)

（4）重點??！
我們拿到的這個paramsValue只是[]*main.aaa名稱，這個值是reflect.type 類型的??！、
我們要的是[]*main.aaa這個類型，而不是要這個名稱！
所以我們要創(chuàng)建這個類型的對象，然后轉(zhuǎn)成相應(yīng)的類型

val := reflect.New(paramsValue)

newT := val.Interface()

fmt.Printf("valValue:%v , valType: %T \n",val,val) //valValue:&[] , valType: reflect.Value

fmt.Printf("newTValue:%v , newTType: %T \n",newT,newT)//newTValue:&[] , newTType: *[]*main.aaa

我們要創(chuàng)建這樣一個類別的對象，雖然go并不是面向?qū)ο蟮木幊?，但是這里可以這樣理解。

為什么要這個類型呢？

因為后面把bytes切片反序列化成這個類型的變量，傳入這個匿名函數(shù)中！

if v.IsValid() { //function valid or not

_ = json.Unmarshal(bytes, newT) //byte to json

}

那么問題又來了，傳入的值的類型是[]*main.aaa 但是我們拿到了*[]*main.aaa這個類型，很明顯是不對的。

1 2	`fmt.Printf("調(diào)用 callback 結(jié)束 callback ret = %s \n", v.Call([]reflect.Value{reflect.ValueOf(newT)}))` `fmt.Printf("*************************\n")`

報錯了！類型不對！

那么我們就要進行去*操作。在反射中，并不是直接加*去除！下面這樣在反射中是不行的。

package main

import (

"fmt"

"reflect"

)

func main(){

var a int = 1

var b *int = &a

var c **int = &b

fmt.Println(a, *b, c)

fmt.Println(reflect.TypeOf(a))

fmt.Println(reflect.TypeOf(*b))

fmt.Println(reflect.TypeOf(b))

}

那么我們可以用reflect.Elem() 將這個去除*

1 2	`fmt.Printf("調(diào)用 callback 結(jié)束 callback ret = %s \n", v.Call([]reflect.Value{reflect.ValueOf(newT).Elem()}))` `fmt.Printf("*************************\n")`

大功告成了！