golang反射有啥用？下面本篇文章給大家介紹一下golang反射（reflection）。有一定的參考價(jià)值，有需要的朋友可以參考一下，希望對(duì)大家有所幫助。

golang(go)是一種過(guò)程編程語(yǔ)言，可用于快速機(jī)器代碼編譯。它是一種靜態(tài)類型的編譯語(yǔ)言。它提供了并發(fā)機(jī)制，可以輕松開(kāi)發(fā)多核和聯(lián)網(wǎng)的機(jī)器級(jí)程序。它是快速，動(dòng)態(tài)類型和解釋語(yǔ)言；它提供對(duì)接口和類型嵌入的支持。

基本了解

在Go語(yǔ)言中，大多數(shù)時(shí)候值/類型/函數(shù)非常直接，要的話，定義一個(gè)。你想要個(gè)Struct

type Foo struct {     A int      B string }

你想要一個(gè)值，你定義出來(lái)

var x Foo

你想要一個(gè)函數(shù)，你定義出來(lái)

func DoSomething(f Foo) {   fmt.Println(f.A, f.B) }

但是有些時(shí)候，你需要搞一些運(yùn)行時(shí)才能確定的東西，比如你要從文件或者網(wǎng)絡(luò)中獲取一些字典數(shù)據(jù)。又或者你要搞一些不同類型的數(shù)據(jù)。在這種情況下，reflection（反射）就有用啦。reflection能夠讓你擁有以下能力：

• 在運(yùn)行時(shí)檢查type

• 在運(yùn)行時(shí)檢查/修改/創(chuàng)建 值/函數(shù)/結(jié)構(gòu)

總的來(lái)說(shuō)，go的reflection圍繞者三個(gè)概念Types, Kinds, Values。 所有關(guān)于反射的操作都在reflect包里面

反射的Power

Type的Power

首先，我們看看如何通過(guò)反射來(lái)獲取值得類型。

varType := reflect.TypeOf(var)

從反射接口可以看到有一大堆得函數(shù)等著我們?nèi)ビ??？梢詮淖⑨尷锩婵吹健７瓷浒J(rèn)我們知道我們要干啥子，比如varType.Elem()就會(huì)panic。因?yàn)镋lem()只有Array, Chan, Map, Ptr, or Slice.這些類型才有這個(gè)方法。具體可以查看測(cè)試代碼。通過(guò)運(yùn)行以下代碼可查看所有reflect函數(shù)的示例

package main import (     "fmt"     "reflect" ) type FooIF interface {     DoSomething()     DoSomethingWithArg(a string)     DoSomethingWithUnCertenArg(a ... string) } type Foo struct {     A int     B string     C struct {         C1 int     } } func (f *Foo) DoSomething() {     fmt.Println(f.A, f.B) } func (f *Foo) DoSomethingWithArg(a string) {     fmt.Println(f.A, f.B, a) } func (f *Foo) DoSomethingWithUnCertenArg(a ... string) {     fmt.Println(f.A, f.B, a[0]) } func (f *Foo) returnOneResult() int {     return 2 } func main() {     var simpleObj Foo     var pointer2obj = &simpleObj     var simpleIntArray = [3]int{1, 2, 3}     var simpleMap = map[string]string{         "a": "b",     }     var simpleChan = make(chan int, 1)     var x uint64     var y uint32     varType := reflect.TypeOf(simpleObj)     varPointerType := reflect.TypeOf(pointer2obj)     // 對(duì)齊之后要多少容量     fmt.Println("Align: ", varType.Align())     // 作為結(jié)構(gòu)體的`field`要對(duì)其之后要多少容量     fmt.Println("FieldAlign: ", varType.FieldAlign())     // 叫啥     fmt.Println("Name: ", varType.Name())     // 絕對(duì)引入路徑     fmt.Println("PkgPath: ", varType.PkgPath())     // 實(shí)際上用了多少內(nèi)存     fmt.Println("Size: ", varType.Size())     // 到底啥類型的     fmt.Println("Kind: ", varType.Kind())     // 有多少函數(shù)     fmt.Println("NumMethod: ", varPointerType.NumMethod())     // 通過(guò)名字獲取一個(gè)函數(shù)     m, success := varPointerType.MethodByName("DoSomethingWithArg")     if success {         m.Func.Call([]reflect.Value{             reflect.ValueOf(pointer2obj),             reflect.ValueOf("sad"),         })     }     // 通過(guò)索引獲取函數(shù)     m = varPointerType.Method(1)     m.Func.Call([]reflect.Value{         reflect.ValueOf(pointer2obj),         reflect.ValueOf("sad2"),     })     // 是否實(shí)現(xiàn)了某個(gè)接口     fmt.Println("Implements:", varPointerType.Implements(reflect.TypeOf((*FooIF)(nil)).Elem()))     //  看看指針多少bit     fmt.Println("Bits: ", reflect.TypeOf(x).Bits())     // 查看array, chan, map, ptr, slice的元素類型     fmt.Println("Elem: ", reflect.TypeOf(simpleIntArray).Elem().Kind())     // 查看Array長(zhǎng)度     fmt.Println("Len: ", reflect.TypeOf(simpleIntArray).Len())     // 查看結(jié)構(gòu)體field     fmt.Println("Field", varType.Field(1))     // 查看結(jié)構(gòu)體field     fmt.Println("FieldByIndex", varType.FieldByIndex([]int{2, 0}))     // 查看結(jié)構(gòu)提field     fi, success2 := varType.FieldByName("A")     if success2 {         fmt.Println("FieldByName", fi)     }     // 查看結(jié)構(gòu)體field     fi, success2 = varType.FieldByNameFunc(func(fieldName string) bool {         return fieldName == "A"     })     if success2 {         fmt.Println("FieldByName", fi)     }     //  查看結(jié)構(gòu)體數(shù)量     fmt.Println("NumField", varType.NumField())     // 查看map的key類型     fmt.Println("Key: ", reflect.TypeOf(simpleMap).Key().Name())     // 查看函數(shù)有多少個(gè)參數(shù)     fmt.Println("NumIn: ", reflect.TypeOf(pointer2obj.DoSomethingWithUnCertenArg).NumIn())     // 查看函數(shù)參數(shù)的類型     fmt.Println("In: ", reflect.TypeOf(pointer2obj.DoSomethingWithUnCertenArg).In(0))     // 查看最后一個(gè)參數(shù)，是否解構(gòu)了     fmt.Println("IsVariadic: ", reflect.TypeOf(pointer2obj.DoSomethingWithUnCertenArg).IsVariadic())     // 查看函數(shù)有多少輸出     fmt.Println("NumOut: ", reflect.TypeOf(pointer2obj.DoSomethingWithUnCertenArg).NumOut())     // 查看函數(shù)輸出的類型     fmt.Println("Out: ", reflect.TypeOf(pointer2obj.returnOneResult).Out(0))     // 查看通道的方向, 3雙向。     fmt.Println("ChanDir: ", int(reflect.TypeOf(simpleChan).ChanDir()))     // 查看該類型是否可以比較。不能比較的slice, map, func     fmt.Println("Comparable: ", varPointerType.Comparable())     // 查看類型是否可以轉(zhuǎn)化成另外一種類型     fmt.Println("ConvertibleTo: ", varPointerType.ConvertibleTo(reflect.TypeOf("a")))     // 該類型的值是否可以另外一個(gè)類型     fmt.Println("AssignableTo: ", reflect.TypeOf(x).AssignableTo(reflect.TypeOf(y))) }

Value的Power

除了檢查變量的類型，你可以通過(guò)reflection來(lái)讀/寫(xiě)/新建一個(gè)值。不過(guò)首先先獲取反射值類型

refVal := reflect.ValueOf(var)

如果你想要修改變量的值。你需要獲取反射指向該變量的指針，具體原因后面解釋

refPtrVal := reflect.ValueOf(&var)

當(dāng)然你有了reflect.Value,通過(guò)Type()方法可以很容易的獲取reflect.Type。如果要改變?cè)撟兞康闹涤?/p>

refPtrVal.Elem().Set(newRefValue)

當(dāng)然Set方法的參數(shù)必須也得是reflect.Value

如果你想創(chuàng)建一個(gè)新的值，用以下下代碼

newPtrVal := reflect.New(varType)

然后在用Elem().Set()來(lái)進(jìn)行值的初始化。當(dāng)然還有不同的value有一大堆的不同的方法。這里就不寫(xiě)了。我們重點(diǎn)看看下面這段官方例子

package main import (     "fmt"     "reflect" ) func main() {     // swap is the implementation passed to MakeFunc.     // It must work in terms of reflect.Values so that it is possible     // to write code without knowing beforehand what the types     // will be.     swap := func(in []reflect.Value) []reflect.Value {         return []reflect.Value{in[1], in[0]}     }     // makeSwap expects fptr to be a pointer to a nil function.     // It sets that pointer to a new function created with MakeFunc.     // When the function is invoked, reflect turns the arguments     // into Values, calls swap, and then turns swap's result slice     // into the values returned by the new function.     makeSwap := func(fptr interface{}) {         // fptr is a pointer to a function.         // Obtain the function value itself (likely nil) as a reflect.Value         // so that we can query its type and then set the value.         fn := reflect.ValueOf(fptr).Elem()         // Make a function of the right type.         v := reflect.MakeFunc(fn.Type(), swap)         // Assign it to the value fn represents.         fn.Set(v)     }     // Make and call a swap function for ints.     var intSwap func(int, int) (int, int)     makeSwap(&intSwap)     fmt.Println(intSwap(0, 1))     // Make and call a swap function for float64s.     var floatSwap func(float64, float64) (float64, float64)     makeSwap(&floatSwap)     fmt.Println(floatSwap(2.72, 3.14)) }

原理

認(rèn)清楚type與interface

go是一個(gè)靜態(tài)類型語(yǔ)言，每一個(gè)變量有static type，比如int，float，何謂static type，我的理解是一定長(zhǎng)度的二進(jìn)制塊與解釋。比如同樣的二進(jìn)制塊00000001 在bool類型中意思是true。而在int類型中解釋是1. 我們看看以下這個(gè)最簡(jiǎn)單的例子

type MyInt int var i int var j MyInt

i,j在內(nèi)存中都是用int這一個(gè)底層類型來(lái)表示，但是在實(shí)際編碼過(guò)程中，在編譯的時(shí)候他們并非一個(gè)類型，你不能直接將i的值賦給j。是不是有點(diǎn)奇怪，你執(zhí)行的時(shí)候編譯器會(huì)告訴你，你不能將MyInt類型的值賦給int類型的值。這個(gè)type不是class也不是python的type.

interface作為一種特殊的type, 表示方法的集合。一個(gè)interface的值可以存任何確定的值只要這個(gè)值實(shí)現(xiàn)了interface的方法。interface{}某些時(shí)候和Java的Object好想，實(shí)際上interface是有兩部分內(nèi)容組成的，實(shí)際的值和值的具體類型。這也可以解釋為什么下面這段代碼和其他語(yǔ)言都不一樣。具體關(guān)于interface的原理可以參考go data structures: interfaces。

package main import (     "fmt" ) type A interface {     x(param int) } type B interface {     y(param int) } type AB struct { } func (ab *AB) x(param int) {     fmt.Printf("%p", ab)     fmt.Println(param) } func (ab *AB) y(param int) {     fmt.Printf("%p", ab)     fmt.Println(param) } func printX(a A){     fmt.Printf("%p", a)     a.x(2) } func printY(b B){     fmt.Printf("%p", b)     b.y(3) } func main() {     var ab = new(AB)     printX(ab)     printY(ab)     var aInfImpl A     var bInfImpl B     aInfImpl = new(AB)     //bInfImpl = aInfImpl  會(huì)報(bào)錯(cuò)     bInfImpl = aInfImpl.(B)     bInfImpl.y(2) }

golang反射三定理

把一個(gè)interface值，拆分出反射對(duì)象

反射僅僅用于檢查接口值的(Value, Type)。如上一章提到的兩個(gè)方法ValueOf和TypeOf。通過(guò)ValueOf我門可以輕易的拿到Type

package main import (     "fmt"     "reflect" ) func main() {     var x float64 = 3.4     fmt.Println("type:", reflect.TypeOf(x)) }

這段代碼輸出

type: float64

那么問(wèn)題就來(lái)了，接口在哪里？只是申明了一個(gè)float64的變量。哪里來(lái)的interface。有的，答案就藏在 TypeOf參數(shù)里面

func TypeOf(i interface{}) Type

當(dāng)我們調(diào)用reflect.TypeOf(x), x首先被存在一個(gè)空的interface里面。然后在被當(dāng)作參數(shù)傳到函數(shù)執(zhí)行棧內(nèi)。** reflect.TypeOf解開(kāi)這個(gè)interface的pair然后恢復(fù)出類型信息**

把反射對(duì)象組合成一個(gè)接口值

就像鏡面反射一樣，go的反射是可逆的。給我一個(gè)reflect.Value。我們能夠恢復(fù)出一個(gè)interface的值。事實(shí)上，以下函數(shù)干的事情就是將Value和Type組狠起來(lái)塞到 interface里面去。所以我們可以

y := v.Interface().(float64) // y will have type float64. fmt.Println(y)

接下來(lái)就是見(jiàn)證奇跡的時(shí)刻。fmt.Println和fmt.Printf的參數(shù)都是interface{}。我們真正都不需要將上面例子的y轉(zhuǎn)化成明確的float64。我就可以去打印他比如

fmt.Println(v.Interface())

甚至我們的interface藏著的那個(gè)type是float64。我們可以直接用占位符來(lái)打印

fmt.Println("Value is %7.len", v.Interface())

再重復(fù)一邊，沒(méi)有必要將v.Interface()的類型強(qiáng)轉(zhuǎn)到float64;這個(gè)空的interface{}包含了concrete type。函數(shù)調(diào)用會(huì)恢復(fù)出來(lái)

要改變一個(gè)反射對(duì)象，其值必須是可設(shè)置的

第三條比較讓你比較困惑。不過(guò)如果我們理解了第一條，那么這條其實(shí)非常好理解。先看一下下面這個(gè)例子

var x float64 = 3.4 v := reflect.ValueOf(x) v.SetFloat(7.1) // Error: will panic.

如果執(zhí)行這段代碼，你會(huì)發(fā)現(xiàn)出現(xiàn)panic以下信息

panic: reflect.Value.SetFloat using unaddressable value

可設(shè)置性是一個(gè)好東西，但不是所有reflect.Value都有他…可以通過(guò)CanSet 函數(shù)來(lái)獲取是否可設(shè)置

var x float64 = 3.4 v := reflect.ValueOf(x) fmt.Println("settability of v:", v.CanSet())

那么到底為什么要有一個(gè)可設(shè)置性呢？可尋址才可設(shè)置，我們?cè)谟胷eflect.ValueOf時(shí)候，實(shí)際上是函數(shù)傳值。獲取x的反射對(duì)象，實(shí)際上是另外一個(gè)float64的內(nèi)存的反射對(duì)象。這個(gè)時(shí)候我們?cè)偃ピO(shè)置該反射對(duì)象的值，沒(méi)有意義。這段內(nèi)存并不是你申明的那個(gè)x。

推薦學(xué)習(xí)：Golang教程