go語言反射實現原理是什么

這篇文章給大家分享的是有關go語言反射實現原理是什么的內容。小編覺得挺實用的，因此分享給大家做個參考，一起跟隨小編過來看看吧。

Go反射的實現和 interface 和 unsafe.Pointer 密切相關。如果對golang的 interface 底層實現還沒有理解，可以去看我之前的文章： Go語言interface底層實現 ， unsafe.Pointer 會在后續的文章中做介紹。

（本文目前使用的Go環境是Go 1.12.9）

interface回顧

首先我們簡單的回顧一下interface的結構，總體上是：

細分下來分為有函數的 iface 和無函數的 eface （就是 interface{} ）;

無函數的 eface

有函數的 iface

靜態類型（static interface type）和動態混合類型（dynamic concrete type）

Go語言中，每個變量都有唯一個 靜態類型 ，這個類型是編譯階段就可以確定的。有的變量可能除了靜態類型之外，還會有 動態混合類型 。

例如以下例子：

//帶函數的interface
var r io.Reader 
tty, err := os.OpenFile("/dev/tty", os.O_RDWR, 0)
if err != nil {
 return nil, err
}
r = tty
//不帶函數的interface
var empty interface{}
empty = tty

有函數的 iface 的例子

我們一句一句來看：第1行， var r io.Reader

第4行至第七行就是簡單的賦值，得到一個 *os.File 的實例,暫且不看了。最后一句第十句 r = tty

無函數的 eface 的例子

我們接著往下看， var empty interface{}

最后是 empty = tty

但是記住：雖然有 動態混合類型 ，但是對外”表現”依然是靜態類型。

Go反射簡介

Go反射有三大法則：

//接口數據  =====》 反射對象
1. Reflection goes from interface value to reflection object.
//反射對象 ===> 接口數據
2. Reflection goes from reflection object to interface value.
// 倘若數據可更改，可通過反射對象來修改它
3. To modify a reflection object, the value must be settable.

Go 的反射就是對以上三項法則的實現。

Go的反射主要由兩部分組成： Type 和 Value ， Type 和 Value 是倆結構體：(這倆結構體具體內容可以略過不看，知道有這回事兒就行了)

Type:

type Type interface {
 Align() int
 FieldAlign() int
 Method(int) Method
 MethodByName(string) (Method, bool)
 NumMethod() int
 Name() string
 PkgPath() string
 Size() uintptr
 String() string
 Kind() Kind
 Implements(u Type) bool
 AssignableTo(u Type) bool
 ConvertibleTo(u Type) bool
 Comparable() bool
 Bits() int
 ChanDir() ChanDir
 IsVariadic() bool
 Elem() Type
 Field(i int) StructField
 FieldByIndex(index []int) StructField
 FieldByName(name string) (StructField, bool)
 FieldByNameFunc(match func(string) bool) (StructField, bool)
 In(i int) Type
 Key() Type
 Len() int
 NumField() int
 NumIn() int
 NumOut() int
 Out(i int) Type
 common() *rtype
 uncommon() *uncommonType
}

Value:

type Value struct {
 typ *rtype
 ptr unsafe.Pointer
 flag
}

你會發現反射的實現和interface的組成很相似，都是由“類型”和“數據值”構成，但是值得注意的是：interface的“類型”和“數據值”是在“一起的”，而反射的“類型”和“數據值”是分開的。

Type 和 Value 提供了非常多的方法：例如獲取對象的屬性列表、獲取和修改某個屬性的值、對象所屬結構體的名字、對象的底層類型(underlying type)等等

Go中的反射，在使用中最核心的就兩個函數：

• reflect.TypeOf(x)

• reflect.ValueOf(x)

這兩個函數可以分別將給定的數據對象轉化為以上的 Type 和 Value 。這兩個都叫做 反射對象

Reflection goes from interface value to reflection object（法則一）

給定一個數據對象，可以將數據對象轉化為反射對象 Type 和 Value 。

事例代碼：

package main

import (
 "fmt"
 "reflect"
)

func main() {
 var x float64 = 3.4

 t := reflect.TypeOf(x)
 v := reflect.ValueOf(x)

 fmt.Println("type:", t) //type: float64

 fmt.Println("value:", v.String()) //value: <float64 Value>
 fmt.Println("type:", v.Type()) // type: float64
 fmt.Println("kind is float64:", v.Kind() == reflect.Float64) //kind is float64: true
 fmt.Println("value:", v.Float()) //value: 3.4

}

由代碼17行可以看出： Value 還可以獲取到當前數據值的 Type 。

所以，法則一的圖應為：

Reflection goes from reflection object to interface value.（法則二）

給定的反射對象，可以轉化為某種類型的數據對象。即法則一的逆向。

注意 Type 是沒法逆向轉換的，仔細想想也合理，如果可逆類型轉化成什么呢？(#^.^#)

承接法則一的代碼：

package main
import (
 "fmt"
 "reflect"
)
func main() {
 var x float64 = 3.4
 t := reflect.TypeOf(x)
 v := reflect.ValueOf(x)
 ...
 o := v.Interface().(float64) // 法則2代碼
 fmt.Println(o)
}

To modify a reflection object, the value must be settable.(法則三)

法則三是說：通過反射對象，可以修改原數據中的內容。

這里說的反射對象，是指 Value ，畢竟 Type 只是表示原數據的類型相關的內容，而 Value 是對應著原數據對象本身。

在目前以上的所有例子中，反射得到的 Value 對象的修改，都是無法直接修改原數據對象的。

package main
import (
 "fmt"
 "reflect"
)
func main() {
 var x float64 = 3.4
 t := reflect.TypeOf(x)
 v := reflect.ValueOf(&x)
 ....
 o := v.Interface().(float64)
 fmt.Println(o)
 v.SetFloat(5.4) //此行會報錯
 fmt.Println(x)
}

這段代碼20行會報一個panic

reflect: reflect.Value.SetFloat using unaddressable value

這句話的意思并不是地址不可達，而是：對象 v 不可設置( settable )。

我們可以通過 Value 結構體的 CanSet() 方法來查看是否可以設置修改新值。

通過以下代碼可以知道 CanSet() 返回值是false。

fmt.Println(v.CanSet()) // false

如何通過反射對象來修改原數據對象的值呢？

如何才能可以通過反射對象來修改原數據對象的值或者說為什么不能設置呢？

原因簡單且純粹：在Go中，任何函數的參數都是值的拷貝，而非原數據。

反射函數 reflect.ValueOf() 也不例外。我們目前得到的反射對象，都是原對象的copy的反射對象，而非原對象本身，所以不可以修改到原對象；即使可以修改，修改一個傳參時候的副本，也毫無意義，不如報錯兒。Go反射第三法則中的制定的 settable 屬性就由此而來，還延伸出了類似于 CanSet() 的方法。

那如何修改呢？

首先，在Go中要想讓函數“有副作用“，傳值必須傳指針類型的。

...

var x float64 = 3.4
v := reflect.ValueOf(&x)

...

此時還不行，因為這樣反射對象對應的是原數據對象的指針類型，必須要拿到當前類型的值類型(*v)，如何做？

Go提供了另外一個方法 Elem()

...
var x float64 = 3.4
v := reflect.ValueOf(&x)
p := v.Elem()
fmt.Println(p.CanSet()) // true
p.SetFloat(7.1)
fmt.Println(x) // 7.1

看以上代碼，就可以修改原數據了。

反射原理

不難發現，go的反射和interface在結構上是如此的相近！都分為兩部分：一部分是 Type 一部分是 value 。

反射會不會是比著interface來實現的？

反射是什么意思？反射的意思是在運行時，能夠動態知道給定數據對象的類型和結構，并有機會修改它！

現在一個數據對象，如何判斷它是什么結構？

數據interface中保存有結構數據呀，只要想辦法拿到該數據對應的內存地址，然后把該數據轉成interface，通過查看interface中的類型結構，就可以知道該數據的結構了呀~

其實以上就是Go反射通俗的原理。

圖可以展示為：

圖中結構中牽扯到的指針，都是 unsafe.Pointer 指針，具體這是個什么指針，后續的文章中會有介紹，在此，你就姑且認為是可以指向Go系統中任意數據的指針就可以。

源碼部分 （以下部分可以忽略，是我在查閱代碼時候遇到的一點點坑。）

我們來看看具體的源碼：源碼在”GO SDK/src/refelct“包中，具體主要是包中的”type.go”和”value.go”這兩個文件。

可以簡單的認為，反射的核心代碼，主要是 reflect.ValueOf() 和 reflect.TypeOf() 這兩個函數。

先看類型轉換： reflect.TypeOf()

// TypeOf returns the reflection Type that represents the dynamic type of i.
// If i is a nil interface value, TypeOf returns nil.
func TypeOf(i interface{}) Type {
 eface := *(*emptyInterface)(unsafe.Pointer(&i))
 return toType(eface.typ)
}

其中出現了兩種數據結構，一個是 Type ，一個是 emptyInterface

分別看看這兩者的代碼：

emptyInterface 在 ”GO SDK/src/reflect/value.go“文件中

// emptyInterface is the header for an interface{} value.
type emptyInterface struct {
 typ *rtype
 word unsafe.Pointer
}

// nonEmptyInterface is the header for an interface value with methods.
type nonEmptyInterface struct {
 // see ../runtime/iface.go:/Itab
 itab *struct {
  ityp *rtype // static interface type
  typ *rtype // dynamic concrete type
  hash uint32 // copy of typ.hash
  _ [4]byte
  fun [100000]unsafe.Pointer // method table
 }
 word unsafe.Pointer
}

什么是go

go是golang的簡稱，golang 是Google開發的一種靜態強類型、編譯型、并發型，并具有垃圾回收功能的編程語言，其語法與 C語言相近，但并不包括如枚舉、異常處理、繼承、泛型、斷言、虛函數等功能。

感謝各位的閱讀！關于“go語言反射實現原理是什么”這篇文章就分享到這里了，希望以上內容可以對大家有一定的幫助，讓大家可以學到更多知識，如果覺得文章不錯，可以把它分享出去讓更多的人看到吧！