反射是 Go 語言比較重要的一個特性之一，雖然在大多數的應用和服務中并不常見，但是很多框架都依賴 Go 語言的反射機制實現一些動態的功能。作為一門靜態語言，Golang 在設計上都非常簡潔，所以在語法上其實并沒有較強的表達能力，但是 Go 語言為我們提供的 reflect 包提供的動態特性卻能夠彌補它在語法上的一些劣勢。

reflect 實現了運行時的反射能力，能夠讓 Golang 的程序操作不同類型的對象，我們可以使用包中的函數 TypeOf 從靜態類型 interface{} 中獲取動態類型信息并通過 ValueOf 獲取數據的運行時表示，通過這兩個函數和包中的其他工具我們就可以得到更強大的表達能力。

概述

在具體介紹反射包的實現原理之前，我們先要對 Go 語言的反射有一些比較簡單的理解，首先 reflect 中有兩對非常重要的函數和類型，我們在上面已經介紹過其中的兩個函數 TypeOf 和 ValueOf，另外兩個類型是 Type 和 Value，它們與函數是一一對應的關系：

類型 Type 是 Golang 反射包中定義的一個接口，我們可以使用 TypeOf 函數獲取任意值的變量的的類型，我們能從這個接口中看到非常多有趣的方法，MethodByName 可以獲取當前類型對應方法的引用、Implements 可以判斷當前類型是否實現了某個接口：

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

反射包中 Value 的類型卻與 Type 不同，Type 是一個接口類型，但是 Value 在 reflect 包中的定義是一個結構體，這個結構體沒有任何對外暴露的成員變量，但是卻提供了很多方法讓我們獲取或者寫入 Value 結構體中存儲的數據：

type Value struct {
// contains filtered or unexported fields
}

func (v Value) Addr() Valuefunc (v Value) Bool() boolfunc (v Value) Bytes() []bytefunc (v Value) Float() float64
...

反射包中的所有方法基本都是圍繞著 Type 和 Value 這兩個對外暴露的類型設計的，我們通過 TypeOf、ValueOf 方法就可以將一個普通的變量轉換成『反射』包中提供的 Type 和 Value，使用反射提供的方法對這些類型進行復雜的操作。

反射法則

運行時反射是程序在運行期間檢查其自身結構的一種方式，它是 元編程 的一種，但是它帶來的靈活性也是一把雙刃劍，過量的使用反射會使我們的程序邏輯變得難以理解并且運行緩慢，我們在這一節中就會介紹 Go 語言反射的三大法則，這能夠幫助我們更好地理解反射的作用。

從接口值可反射出反射對象；

從反射對象可反射出接口值；

要修改反射對象，其值必須可設置；

第一法則

反射的第一條法則就是，我們能夠將 Go 語言中的接口類型變量轉換成反射對象，上面提到的reflect.TypeOf 和 reflect.ValueOf 就是完成這個轉換的兩個最重要方法，如果我們認為 Go 語言中的類型和反射類型是兩個不同『世界』的話，那么這兩個方法就是連接這兩個世界的橋梁。

我們通過以下例子簡單介紹這兩個方法的作用，其中 TypeOf 獲取了變量 author 的類型也就是 string 而 ValueOf 獲取了變量的值 draven，如果我們知道了一個變量的類型和值，那么也就意味著我們知道了關于這個變量的全部信息。

package main

import (
"fmt"
"reflect"
)

func main() {
author := "draven"
fmt.Println("TypeOf author:", reflect.TypeOf(author))
fmt.Println("ValueOf author:", reflect.ValueOf(author))
}

$ go run main.go
TypeOf author: string
ValueOf author: draven

從變量的類型上我們可以獲當前類型能夠執行的方法 Method 以及當前類型實現的接口等信息；

• 對于結構體，可以獲取字段的數量并通過下標和字段名獲取字段 StructField；

• 對于哈希表，可以獲取哈希表的 Key 類型；

• 對于函數或方法，可以獲得入參和返回值的類型；

• ...

總而言之，使用 TypeOf 和 ValueOf 能夠將 Go 語言中的變量轉換成反射對象，在這時我們能夠獲得幾乎一切跟當前類型相關數據和操作，然后就可以用這些運行時獲取的結構動態的執行一些方法。

很多讀者可能都會對這個副標題產生困惑，為什么是從接口到反射對象，如果直接調用 reflect.ValueOf(1)，看起來是從基本類型 int 到反射類型，但是 TypeOf 和 ValueOf 兩個方法的入參其實是 interface{} 類型。

我們在之前已經在 函數調用 一節中介紹過，Go 語言的函數調用都是值傳遞的，變量會在方法調用前進行類型轉換，也就是 int 類型的基本變量會被轉換成 interface{} 類型，這也就是第一條法則介紹的是從接口到反射對象。

第二法則

我們既然能夠將接口類型的變量轉換成反射對象類型，那么也需要一些其他方法將反射對象還原成成接口類型的變量，reflect 中的 Interface 方法就能完成這項工作：

然而調用 Interface 方法我們也只能獲得 interface{} 類型的接口變量，如果想要將其還原成原本的類型還需要經過一次強制的類型轉換，如下所示：

v := reflect.ValueOf(1)
v.Interface{}.(int)

這個過程就像從接口值到反射對象的鏡面過程一樣，從接口值到反射對象需要經過從基本類型到接口類型的類型轉換和從接口類型到反射對象類型的轉換，反過來的話，所有的反射對象也都需要先轉換成接口類型，再通過強制類型轉換變成原始類型：

當然不是所有的變量都需要類型轉換這一過程，如果本身就是 interface{} 類型的，那么它其實并不需要經過類型轉換，對于大多數的變量來說，類型轉換這一過程很多時候都是隱式發生的，只有在我們需要將反射對象轉換回基本類型時才需要做顯示的轉換操作。

第三法則

Go 語言反射的最后一條法則是與值是否可以被更改相關的，如果我們想要更新一個 reflect.Value，那么它持有的值一定是可以被更新的，假設我們有以下代碼：

func main() {
i := 1
v := reflect.ValueOf(i)
v.SetInt(10)
fmt.Println(i)
}

$ go run reflect.go
panic: reflect: reflect.flag.mustBeAssignable using unaddressable value

goroutine 1 [running]:
reflect.flag.mustBeAssignableSlow(0x82, 0x1014c0)
/usr/local/go/src/reflect/value.go:247 +0x180
reflect.flag.mustBeAssignable(...)
/usr/local/go/src/reflect/value.go:234
reflect.Value.SetInt(0x100dc0, 0x414020, 0x82, 0x1840, 0xa, 0x0)
/usr/local/go/src/reflect/value.go:1606 +0x40
main.main()
/tmp/sandbox590309925/prog.go:11 +0xe0

運行上述代碼時會導致程序 panic 并報出 reflect: reflect.flag.mustBeAssignable using unaddressable value 錯誤，仔細想一下其實能夠發現出錯的原因，Go 語言的 函數調用 都是傳值的，所以我們得到的反射對象其實跟最開始的變量沒有任何關系，沒有任何變量持有復制出來的值，所以直接對它修改會導致崩潰。

想要修改原有的變量我們只能通過如下所示的方法，首先通過 reflect.ValueOf 獲取變量指針，然后通過 Elem 方法獲取指針指向的變量并調用 SetInt 方法更新變量的值：

func main() {
i := 1
v := reflect.ValueOf(&i)
v.Elem().SetInt(10)
fmt.Println(i)
}

$ go run reflect.go
10

這種獲取指針對應的 reflect.Value 并通過 Elem 方法迂回的方式就能夠獲取到可以被設置的變量，這一復雜的過程主要也是因為 Go 語言的函數調用都是值傳遞的，我們可以將上述代碼理解成：

func main() {
i := 1
v := &i
*v = 10
}

如果不能直接操作 i 變量修改其持有的值，我們就只能獲取 i 變量所在地址并使用 *v 修改所在地址中存儲的整數。

實現原理

我們在上面的部分已經對 Go 語言中反射的三大法則進行了介紹，對于接口值和反射對象互相轉換的操作和過程都有了一定的了解，接下來我們就深入研究反射的實現原理，分析 reflect 包提供的方法是如何獲取接口值對應的反射類型和值、判斷協議的實現以及方法調用的過程。

類型和值

Golang 的 interface{} 類型在語言內部都是通過 emptyInterface 這個結構體來表示的，其中包含一個 rtype 字段用于表示變量的類型以及一個 word 字段指向內部封裝的數據：

type emptyInterface struct {
typ *rtype
word unsafe.Pointer
}

用于獲取變量類型的 TypeOf 函數就是將傳入的 i 變量強制轉換成 emptyInterface 類型并獲取其中存儲的類型信息 rtype：

func TypeOf(i interface{}) Type {
eface := *(*emptyInterface)(unsafe.Pointer(&i))
return toType(eface.typ)
}

func toType(t *rtype) Type {
if t == nil {
return nil
}
return t
}

rtype 就是一個實現了 Type 接口的接口體，我們能在 reflect 包中找到如下所示的 Name 方法幫助我們獲取當前類型的名稱等信息：

func (t *rtype) String() string {
s := t.nameOff(t.str).name()
if t.tflag&tflagExtraStar != 0 {
return s[1:]
}
return s
}

TypeOf 函數的實現原理其實并不復雜，它只是將一個 interface{} 變量轉換成了內部的 emptyInterface 表示，然后從中獲取相應的類型信息。

用于獲取接口值 Value 的函數 ValueOf 實現也非常簡單，在該函數中我們先調用了 escapes 函數保證當前值逃逸到堆上，然后通過 unpackEface 方法從接口中獲取 Value 結構體：

func ValueOf(i interface{}) Value {
if i == nil {
return Value{}
}

escapes(i)

return unpackEface(i)
}

func unpackEface(i interface{}) Value {
e := (*emptyInterface)(unsafe.Pointer(&i))
t := e.typ
if t == nil {
return Value{}
}
f := flag(t.Kind())
if ifaceIndir(t) {
f |= flagIndir
}
return Value{t, e.word, f}
}

unpackEface 函數會將傳入的接口 interface{} 轉換成 emptyInterface 結構體然后將其中表示接口值類型、指針以及值的類型包裝成 Value 結構體并返回。

TypeOf 和 ValueOf 兩個方法的實現其實都非常簡單，從一個 Go 語言的基本變量中獲取反射對象以及類型的過程中，TypeOf 和 ValueOf 兩個方法的執行過程并不是特別的復雜，我們還需要注意基本變量到接口值的轉換過程：

package main

import (
"reflect"
)

func main() {
i := 20
_ = reflect.TypeOf(i)
}

$ go build -gcflags="-S -N" main.go
...
MOVQ $20, ""..autotmp_20+56(SP) // autotmp = 20
LEAQ type.int(SB), AX // AX = type.int(SB)
MOVQ AX, ""..autotmp_19+280(SP) // autotmp_19+280(SP) = type.int(SB)
LEAQ ""..autotmp_20+56(SP), CX // CX = 20
MOVQ CX, ""..autotmp_19+288(SP) // autotmp_19+288(SP) = 20
...

我們使用 -S -N 編譯指令編譯了上述代碼，從這段截取的匯編語言中我們可以發現，在函數調用之前其實發生了類型轉換，我們將 int 類型的變量轉換成了占用 16 字節 autotmp_19+280(SP) ~ autotmp_19+288(SP) 的 interface{} 結構體，兩個 LEAQ 指令分別獲取了類型的指針 type.int(SB) 以及變量 i 所在的地址。

總的來說，在 Go 語言的編譯期間我們就完成了類型轉換的工作，將變量的類型和值轉換成了 interface{} 等待運行期間使用 reflect 包獲取其中存儲的信息。

更新變量

當我們想要更新一個 reflect.Value 時，就需要調用 Set 方法更新反射對象，該方法會調用 mustBeAssignable 和 mustBeExported 分別檢查當前反射對象是否是可以被設置的和對外暴露的公開字段：

func (v Value) Set(x Value) {
v.mustBeAssignable()
x.mustBeExported() // do not let unexported x leak
var target unsafe.Pointer
if v.kind() == Interface {
target = v.ptr
}
x = x.assignTo("reflect.Set", v.typ, target)
if x.flag&flagIndir != 0 {
typedmemmove(v.typ, v.ptr, x.ptr)
} else {
*(*unsafe.Pointer)(v.ptr) = x.ptr
}
}

Set 方法中會調用 assignTo，該方法會返回一個新的 reflect.Value 反射對象，我們可以將反射對象的指針直接拷貝到被設置的反射變量上：

func (v Value) assignTo(context string, dst *rtype, target unsafe.Pointer) Value {
if v.flag&flagMethod != 0 {
v = makeMethodValue(context, v)
}

switch {
case directlyAssignable(dst, v.typ):
fl := v.flag&(flagAddr|flagIndir) | v.flag.ro()
fl |= flag(dst.Kind())
return Value{dst, v.ptr, fl}

case implements(dst, v.typ):
if target == nil {
target = unsafe_New(dst)
}
if v.Kind() == Interface && v.IsNil() {
return Value{dst, nil, flag(Interface)}
}
x := valueInterface(v, false)
if dst.NumMethod() == 0 {
*(*interface{})(target) = x
} else {
ifaceE2I(dst, x, target)
}
return Value{dst, target, flagIndir | flag(Interface)}
}

panic(context + ": value of type " + v.typ.String() + " is not assignable to type " + dst.String())
}

assignTo 會根據當前和被設置的反射對象類型創建一個新的 Value 結構體，當兩個反射對象的類型是可以被直接替換時，就會直接將目標反射對象返回；如果當前反射對象是接口并且目標對象實現了接口，就會將目標對象簡單包裝成接口值，上述方法返回反射對象的 ptr 最終會覆蓋當前反射對象中存儲的值。

實現協議

reflect 包還為我們提供了 Implements 方法用于判斷某些類型是否遵循協議實現了全部的方法，在 Go 語言中想要獲取結構體的類型還是比較容易的，但是想要獲得接口的類型就需要比較黑魔法的方式：

reflect.TypeOf((*<interface>)(nil)).Elem()

只有通過上述方式才能獲得一個接口類型的反射對象，假設我們有以下代碼，我們需要判斷 CustomError 是否實現了 Go 語言標準庫中的 error 協議：

type CustomError struct{}

func (*CustomError) Error() string {
return ""
}

func main() {
typeOfError := reflect.TypeOf((*error)(nil)).Elem()
customErrorPtr := reflect.TypeOf(&CustomError{})
customError := reflect.TypeOf(CustomError{})

fmt.Println(customErrorPtr.Implements(typeOfError)) // #=> true
fmt.Println(customError.Implements(typeOfError)) // #=> false
}

運行上述代碼我們會發現 CustomError 類型并沒有實現 error 接口，而 *CustomError 指針類型卻實現了接口，這其實也比較好理解，我們在 接口 一節中也介紹過可以使用結構體和指針兩種不同的類型實現接口。

func (t *rtype) Implements(u Type) bool {
if u == nil {
panic("reflect: nil type passed to Type.Implements")
}
if u.Kind() != Interface {
panic("reflect: non-interface type passed to Type.Implements")
}
return implements(u.(*rtype), t)
}

Implements 方法會檢查傳入的類型是不是接口，如果不是接口或者是空值就會直接 panic 中止當前程序，否則就會調用私有的函數 implements 判斷類型之間是否有實現關系：

func implements(T, V *rtype) bool {
t := (*interfaceType)(unsafe.Pointer(T))
if len(t.methods) == 0 {
return true
}

// ...

v := V.uncommon()
i := 0
vmethods := v.methods()
for j := 0; j < int(v.mcount); j++ {
tm := &t.methods[i]
tmName := t.nameOff(tm.name)
vm := vmethods[j]
vmName := V.nameOff(vm.name)
if vmName.name() == tmName.name() && V.typeOff(vm.mtyp) == t.typeOff(tm.typ) {
if i++; i >= len(t.methods) {
return true
}
}
}
return false
}

如果接口中不包含任何方法，也就意味著這是一個空的 interface{}，任意的類型都可以實現該協議，所以就會直接返回 true。

在其他情況下，由于方法是按照一定順序排列的，implements 中就會維護兩個用于遍歷接口和類型方法的索引 i 和 j，所以整個過程的實現復雜度是 O(n+m)，最多只會進行 n + m 次數的比較，不會出現次方級別的復雜度。

方法調用

作為一門靜態語言，如果我們想要通過 reflect 包利用反射在運行期間執行方法并不是一件容易的事情，下面的代碼就使用了反射來執行 Add(0, 1) 這一表達式：

func Add(a, b int) int { return a + b }

func main() {
v := reflect.ValueOf(Add)
if v.Kind() != reflect.Func {
return
}
t := v.Type()
argv := make([]reflect.Value, t.NumIn())
for i := range argv {
if t.In(i).Kind() != reflect.Int {
return
}
argv[i] = reflect.ValueOf(i)
}
result := v.Call(argv)
if len(result) != 1 || result[0].Kind() != reflect.Int {
return
}
fmt.Println(result[0].Int()) // #=> 1
}

通過 reflect.ValueOf 獲取函數 Add 對應的反射對象；

根據反射對象 NumIn 方法返回的參數個數創建 argv 數組；

多次調用 reflect.Value 逐一設置 argv 數組中的各個參數；

調用反射對象 Add 的 Call 方法并傳入參數列表；

獲取返回值數組、驗證數組的長度以及類型并打印其中的數據；

使用反射來調用方法非常復雜，原本只需要一行代碼就能完成的工作，現在需要 10 多行代碼才能完成，但是這也是在靜態語言中使用這種動態特性需要付出的成本，理解這個調用過程能夠幫助我們深入理解 Go 語言函數和方法調用的原理。

func (v Value) Call(in []Value) []Value {
v.mustBe(Func)
v.mustBeExported()
return v.call("Call", in)
}

Call 作為反射包運行時調用方法的入口，通過兩個 MustBe 方法保證了當前反射對象的類型和可見性，隨后調用 call 方法完成運行時方法調用的過程，這個過程會被分成以下的幾個部分：

檢查輸入參數的合法性以及類型等信息；

將傳入的 reflect.Value 參數數組設置到棧上；

通過函數指針和輸入參數調用函數；

從棧上獲取函數的返回值；

我們將按照上面的順序依次詳細介紹使用 ?reflect 進行函數調用的幾個過程。

參數檢查

參數檢查是通過反射調用方法的第一步，在參數檢查期間我們會從反射對象中取出當前的函數指針 unsafe.Pointer，如果待執行的函數是方法，就會通過 methodReceiver 函數獲取方法的接受者和函數指針。

func (v Value) call(op string, in []Value) []Value {
t := (*funcType)(unsafe.Pointer(v.typ))
var (
fn unsafe.Pointer
rcvr Value
rcvrtype *rtype
)
if v.flag&flagMethod != 0 {
rcvr = v
rcvrtype, t, fn = methodReceiver(op, v, int(v.flag)>>flagMethodShift)
} else if v.flag&flagIndir != 0 {
fn = *(*unsafe.Pointer)(v.ptr)
} else {
fn = v.ptr
}

n := t.NumIn()
if len(in) < n {
panic("reflect: Call with too few input arguments")
}
if len(in) > n {
panic("reflect: Call with too many input arguments")
}
for i := 0; i < n; i++ {
if xt, targ := in[i].Type(), t.In(i); !xt.AssignableTo(targ) {
panic("reflect: " + op + " using " + xt.String() + " as type " + targ.String())
}
}

nin := len(in)
if nin != t.NumIn() {
panic("reflect.Value.Call: wrong argument count")
}

除此之外，在參數檢查的過程中我們還會檢查當前傳入參數的個數以及所有參數的類型是否能被傳入該函數中，任何參數不匹配的問題都會導致當前函數直接 panic 并中止整個程序。

準備參數

當我們已經對當前方法的參數驗證完成之后，就會進入函數調用的下一個階段，為函數調用準備參數，在前面的章節 函數調用 中我們已經介紹過 Go 語言的函數調用的慣例，所有的參數都會被依次放置到堆棧上。

nout := t.NumOut()
frametype, _, retOffset, _, framePool := funcLayout(t, rcvrtype)

var args unsafe.Pointer
if nout == 0 {
args = framePool.Get().(unsafe.Pointer)
} else {
args = unsafe_New(frametype)
}
off := uintptr(0)

if rcvrtype != nil {
storeRcvr(rcvr, args)
off = ptrSize
}
for i, v := range in {
targ := t.In(i).(*rtype)
a := uintptr(targ.align)
off = (off + a - 1) &^ (a - 1)
n := targ.size
if n == 0 {
v.assignTo("reflect.Value.Call", targ, nil)
continue
}
addr := add(args, off, "n > 0")
v = v.assignTo("reflect.Value.Call", targ, addr)
if v.flag&flagIndir != 0 {
typedmemmove(targ, addr, v.ptr)
} else {
*(*unsafe.Pointer)(addr) = v.ptr
}
off += n
}

通過 funcLayout 函數計算當前函數需要的參數和返回值的堆棧布局，也就是每一個參數和返回值所占的空間大小；

如果當前函數有返回值，需要為當前函數的參數和返回值分配一片內存空間 args；

如果當前函數是方法，需要向將方法的接受者拷貝到 args 這片內存中；

將所有函數的參數按照順序依次拷貝到對應 args 內存中

使用 funcLayout 返回的參數計算參數在內存中的位置；

通過 typedmemmove 或者尋址的放置拷貝參數；

準備參數的過程其實就是計算各個參數和返回值占用的內存空間，并將所有的參數都拷貝內存空間對應的位置上。

調用函數

準備好調用函數需要的全部參數之后，就會通過以下的表達式開始方法的調用了，我們會向該函數中傳入棧類型、函數指針、參數和返回值的內存空間、棧的大小以及返回值的偏移量：

call(frametype, fn, args, uint32(frametype.size), uint32(retOffset))

這個函數實際上并不存在，它會在編譯期間被鏈接到 runtime.reflectcall 這個用匯編實現的函數上，我們在這里并不會展開介紹該函數的具體實現，感興趣的讀者可以自行了解其實現原理。

處理返回值

當函數調用結束之后，我們就會開始處理函數的返回值了，如果函數沒有任何返回值我們就會直接清空 args 中的全部內容來釋放內存空間，不過如果當前函數有返回值就會進入另一個分支：

var ret []Value
if nout == 0 {
typedmemclr(frametype, args)
framePool.Put(args)
} else {
typedmemclrpartial(frametype, args, 0, retOffset)

ret = make([]Value, nout)
off = retOffset
for i := 0; i < nout; i++ {
tv := t.Out(i)
a := uintptr(tv.Align())
off = (off + a - 1) &^ (a - 1)
if tv.Size() != 0 {
fl := flagIndir | flag(tv.Kind())
ret[i] = Value{tv.common(), add(args, off, "tv.Size() != 0"), fl}
} else {
ret[i] = Zero(tv)
}
off += tv.Size()
}
}

return ret
}

將 args 中與輸入參數有關的內存空間清空；

創建一個 nout 長度的切片用于保存由反射對象構成的返回值數組；

從函數對象中獲取返回值的類型和內存大小，將 args 內存中的數據轉換成 reflect.Value 類型的返回值；

由 reflect.Value 構成的 ret 數組最終就會被返回到上層，使用反射進行函數調用的過程也就結束了。

總結

我們在這一節中 Go 語言的 reflect 包為我們提供的多種能力，其中包括如何使用反射來動態修改變量、判斷類型是否實現了某些協議以及動態調用方法，通過對反射包中方法原理的分析幫助我們理解之前看起來比較怪異、令人困惑的現象。

Reference

• The Laws of Reflection

• Reflect Examples

推薦閱讀

• 大神是如何學習 Go 語言之調度器與 Goroutine

---

喜歡本文的朋友，歡迎關注“Go語言中文網”：

Go語言中文網啟用微信學習交流群，歡迎加微信：274768166

總結

以上是生活随笔為你收集整理的go interface 转int_大神是如何学习 Go 语言之反射的实现原理的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。