Golang語言學習拿捏Go反射示例教程

Posted on by

1. 反射簡介

1.1 反射是什麼？

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

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

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

var a int

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

現在我並不知道變量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)的區別
	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 屬於一種結構體類別，因此類別為 struct
}

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

1.2 為什麼需要反射？

在開發當中，當我們對於某一個函數進行值的處理的時候，但是為瞭保證這個函數能接受更多類型的值，因為go是強類型的語言，雖然interface可以接受所有的數據類型，但是在處理數據的時候，要對不同類型進行不同的處理的時候就會顯得代碼十分冗餘，於是我們可以使用反射來進行對傳入參數的判斷與處理。

詳細見例題

2. reflect包

2.1 基本反射

reflect.TypeOf()			 //獲取變量的類型，返回reflect.Type類型
reflect.ValueOf()			 //獲取變量的值，返回reflect.Value類型
reflect.Value.Kind()		 //獲取變量的類別，返回一個常量
reflect.Value.Interface()	 //轉換成interface{}類型

2.2 反射與指針

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

reflect.ValueOf(xxx).Elem()

2.3 反射與對象

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

func CreatePrimitiveObjects(t reflect.Type) reflect.Value {
    return reflect.Zero(t)
}

也可以使用

reflect.New()

來進行創建原始對象。

2.4 反射與函數

如果反射值對象（reflect.Value）中值的類型為函數時，可以通過reflect.Value調用該函數。使用反射調用函數時，需要將參數使用反射值對象的切片[]reflect.Value構造後傳入Call()方法中，調用完成時，函數的返回值通過[]reflect.Value返回。
在反射中 函數 和 方法 的類型（Type）都是 reflect.Func，如果要調用函數的話，可以通過 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{})		 //無參數
	FanOneHaveArgs := reflect.ValueOf(FanOneWoW).Call([]reflect.Value{reflect.ValueOf("我")})  //有參數
	fmt.Println(FanOneNotArgs[0])
	fmt.Println(FanOneHaveArgs[0])
}

2.5 反射例子

填寫fn函數使得輸出為

在這裡插入圖片描述

要求不使用任何的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，不然好像會報錯，我就是這樣。

go test xxx_test.go
go test -v xxx_test.go

（2）其次是瞭解這個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}]"))

可以看到這是一個*aaa類型的數組。那麼我們任務就是反射出fn這個函數裡面的匿名函數，然後調用反射出來的這個匿名函數，並將參數傳入其中。

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

（3）那麼我們先ValueOf和TypeOf這個interface{}，然後再看這個匿名函數各種的值

func fn(callback interface{}, bytes []byte) {
	v := reflect.ValueOf(callback)  //0xbaff40
	t := reflect.TypeOf(callback)  //func([]*main.aaa) string
}

我們可以看到入參的函數的Type是func([]*main.aaa) string 所以我們可以用

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

拿到匿名函數的傳入參數

（4）重點！！
我們拿到的這個paramsValue隻是[]*main.aaa名稱，這個值是reflect.type 類型的！！、
我們要的是[]*main.aaa這個類型，而不是要這個名稱！
所以我們要創建這個類型的對象，然後轉成相應的類型

	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

我們要創建這樣一個類別的對象，雖然go並不是面向對象的編程，但是這裡可以這樣理解。

為什麼要這個類型呢？

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

	if v.IsValid() {                       			//function valid or not
		_ = json.Unmarshal(bytes, newT)               //byte to json
	}

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

	fmt.Printf("調用 callback 結束 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() 將這個去除*

	fmt.Printf("調用 callback 結束 callback ret = %s \n", v.Call([]reflect.Value{reflect.ValueOf(newT).Elem()}))
	fmt.Printf("*************************\n")

大功告成瞭！

3. 總結

以前我是很少使用反射的，基本在項目中就沒用過，但是暑期實習的時候，第一個任務就是寫反射接口，那麼就瘋狂補這方面的知識，反射對於我來說，確實有點難理解，花瞭我兩天時間才做出來。

原來我的想法是用if判斷類型的，或是斷言然後用switch判斷類型的，但是這樣實用性不高，換瞭一個名稱的話就要改代碼瞭。比如現在是結構體aaa，換成bbb就不管用瞭。

現在這種的話，直接將這個類型的反射成一個對象，然後再對這個對象進行賦值操作，就更加靈活！

學到瞭！

實習很痛苦！但是學到瞭很多新知識！還有好多大佬帶！還有工資拿！也舒服！

以上就是Golang語言學習拿捏Go反射示例教程的詳細內容，更多關於Go反射教程的資料請關註WalkonNet其它相關文章！

推薦閱讀：