golang反射的作用是什么？

今天小編給大家分享的是golang反射的作用是什么，相信很多人都不太了解，為了讓大家更加了解golang反射的作用，所以給大家總結了以下內容，一起往下看吧。一定會有所收獲的哦。

golang(go)是一種過程編程語言，可用于快速機器代碼編譯。它是一種靜態類型的編譯語言。它提供了并發機制，可以輕松開發多核和聯網的機器級程序。它是快速，動態類型和解釋語言；它提供對接口和類型嵌入的支持。

基本了解

在Go語言中，大多數時候值/類型/函數非常直接，要的話，定義一個。你想要個Struct

type Foo struct {
    A int 
    B string
}

你想要一個值，你定義出來

var x Foo

你想要一個函數，你定義出來

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

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

• 在運行時檢查type

• 在運行時檢查/修改/創建 值/函數/結構

總的來說，go的reflection圍繞者三個概念Types, Kinds, Values。 所有關于反射的操作都在reflect包里面

反射的Power

Type的Power

首先，我們看看如何通過反射來獲取值得類型。

varType := reflect.TypeOf(var)

從反射接口可以看到有一大堆得函數等著我們去用。可以從注釋里面看到。反射包默認我們知道我們要干啥子，比如varType.Elem()就會panic。因為Elem()只有Array, Chan, Map, Ptr, or Slice.這些類型才有這個方法。具體可以查看測試代碼。通過運行以下代碼可查看所有reflect函數的示例

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)
    // 對齊之后要多少容量
    fmt.Println("Align: ", varType.Align())
    // 作為結構體的`field`要對其之后要多少容量
    fmt.Println("FieldAlign: ", varType.FieldAlign())
    // 叫啥
    fmt.Println("Name: ", varType.Name())
    // 絕對引入路徑
    fmt.Println("PkgPath: ", varType.PkgPath())
    // 實際上用了多少內存
    fmt.Println("Size: ", varType.Size())
    // 到底啥類型的
    fmt.Println("Kind: ", varType.Kind())
    // 有多少函數
    fmt.Println("NumMethod: ", varPointerType.NumMethod())
    // 通過名字獲取一個函數
    m, success := varPointerType.MethodByName("DoSomethingWithArg")
    if success {
        m.Func.Call([]reflect.Value{
            reflect.ValueOf(pointer2obj),
            reflect.ValueOf("sad"),
        })
    }
    // 通過索引獲取函數
    m = varPointerType.Method(1)
    m.Func.Call([]reflect.Value{
        reflect.ValueOf(pointer2obj),
        reflect.ValueOf("sad2"),
    })
    // 是否實現了某個接口
    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長度
    fmt.Println("Len: ", reflect.TypeOf(simpleIntArray).Len())
    // 查看結構體field
    fmt.Println("Field", varType.Field(1))
    // 查看結構體field
    fmt.Println("FieldByIndex", varType.FieldByIndex([]int{2, 0}))
    // 查看結構提field
    fi, success2 := varType.FieldByName("A")
    if success2 {
        fmt.Println("FieldByName", fi)
    }
    // 查看結構體field
    fi, success2 = varType.FieldByNameFunc(func(fieldName string) bool {
        return fieldName == "A"
    })
    if success2 {
        fmt.Println("FieldByName", fi)
    }
    //  查看結構體數量
    fmt.Println("NumField", varType.NumField())
    // 查看map的key類型
    fmt.Println("Key: ", reflect.TypeOf(simpleMap).Key().Name())
    // 查看函數有多少個參數
    fmt.Println("NumIn: ", reflect.TypeOf(pointer2obj.DoSomethingWithUnCertenArg).NumIn())
    // 查看函數參數的類型
    fmt.Println("In: ", reflect.TypeOf(pointer2obj.DoSomethingWithUnCertenArg).In(0))
    // 查看最后一個參數，是否解構了
    fmt.Println("IsVariadic: ", reflect.TypeOf(pointer2obj.DoSomethingWithUnCertenArg).IsVariadic())
    // 查看函數有多少輸出
    fmt.Println("NumOut: ", reflect.TypeOf(pointer2obj.DoSomethingWithUnCertenArg).NumOut())
    // 查看函數輸出的類型
    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())
    // 查看類型是否可以轉化成另外一種類型
    fmt.Println("ConvertibleTo: ", varPointerType.ConvertibleTo(reflect.TypeOf("a")))
    // 該類型的值是否可以另外一個類型
    fmt.Println("AssignableTo: ", reflect.TypeOf(x).AssignableTo(reflect.TypeOf(y)))
}

Value的Power

除了檢查變量的類型，你可以通過reflection來讀/寫/新建一個值。不過首先先獲取反射值類型

refVal := reflect.ValueOf(var)

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

refPtrVal := reflect.ValueOf(&var)

當然你有了reflect.Value,通過Type()方法可以很容易的獲取reflect.Type。如果要改變該變量的值用

refPtrVal.Elem().Set(newRefValue)

當然Set方法的參數必須也得是reflect.Value

如果你想創建一個新的值，用以下下代碼

newPtrVal := reflect.New(varType)

然后在用Elem().Set()來進行值的初始化。當然還有不同的value有一大堆的不同的方法。這里就不寫了。我們重點看看下面這段官方例子

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

原理

認清楚type與interface

go是一個靜態類型語言，每一個變量有static type，比如int，float，何謂static type，我的理解是一定長度的二進制塊與解釋。比如同樣的二進制塊00000001 在bool類型中意思是true。而在int類型中解釋是1. 我們看看以下這個最簡單的例子

type MyInt int
var i int
var j MyInt

i,j在內存中都是用int這一個底層類型來表示，但是在實際編碼過程中，在編譯的時候他們并非一個類型，你不能直接將i的值賦給j。是不是有點奇怪，你執行的時候編譯器會告訴你，你不能將MyInt類型的值賦給int類型的值。這個type不是class也不是python的type.

interface作為一種特殊的type, 表示方法的集合。一個interface的值可以存任何確定的值只要這個值實現了interface的方法。interface{}某些時候和Java的Object好想，實際上interface是有兩部分內容組成的，實際的值和值的具體類型。這也可以解釋為什么下面這段代碼和其他語言都不一樣。具體關于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  會報錯
    bInfImpl = aInfImpl.(B)
    bInfImpl.y(2)
}

golang反射三定理

把一個interface值，拆分出反射對象

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

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

這段代碼輸出

type: float64

那么問題就來了，接口在哪里？只是申明了一個float64的變量。哪里來的interface。有的，答案就藏在 TypeOf參數里面

func TypeOf(i interface{}) Type

當我們調用reflect.TypeOf(x), x首先被存在一個空的interface里面。然后在被當作參數傳到函數執行棧內。** reflect.TypeOf解開這個interface的pair然后恢復出類型信息**

把反射對象組合成一個接口值

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

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

接下來就是見證奇跡的時刻。fmt.Println和fmt.Printf的參數都是interface{}。我們真正都不需要將上面例子的y轉化成明確的float64。我就可以去打印他比如

fmt.Println(v.Interface())

甚至我們的interface藏著的那個type是float64。我們可以直接用占位符來打印

fmt.Println("Value is %7.le\n", v.Interface())

再重復一邊，沒有必要將v.Interface()的類型強轉到float64;這個空的interface{}包含了concrete type。函數調用會恢復出來

要改變一個反射對象，其值必須是可設置的

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

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

如果執行這段代碼，你會發現出現panic以下信息

panic: reflect.Value.SetFloat using unaddressable value

可設置性是一個好東西，但不是所有reflect.Value都有他...可以通過CanSet 函數來獲取是否可設置

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

那么到底為什么要有一個可設置性呢？可尋址才可設置，我們在用reflect.ValueOf時候，實際上是函數傳值。獲取x的反射對象，實際上是另外一個float64的內存的反射對象。這個時候我們再去設置該反射對象的值，沒有意義。這段內存并不是你申明的那個x。

以上就是golang反射的作用是什么的詳細內容了，看完之后是否有所收獲呢？如果想了解更多相關內容，歡迎來億速云行業資訊。