Go 語言：The Laws of Reflection 中文版

浮x塵發表於2018-11-27
Go

翻譯了一篇 Go 官方部落格介紹反射的文章：

簡介

在電腦科學中，反射是一種在執行時檢測自身結構（型別）的能力，反射構成超程式設計的基礎，也是混亂的來源。

在這篇文章中我們會嘗試澄清 Go 語言中的反射如何運作，每個語言的反射模型都不一樣（典型如 Java），很多語言甚至不支援反射，因此在這篇文章中說明的只是 Go 語言反射。

型別和介面

因為整個反射模型構建在型別系統之上，我們先複習一遍 Go 中的型別。

Go 是靜態型別語言，任何變數在編譯時都有明確的型別，如 int、float32、*MyType, []byte 等型別...

type MyInt int

var i int
var j MyInt
複製程式碼

變數 i 的型別為 int，變數 j 的型別為 MyInt。它們兩個明顯有著不同的靜態型別，除此之外又有著相同的基本型別 int。因為靜態型別不同，所以兩者必須在轉換後才能進行賦值。

介面型別是型別系統中非常重要的一個分類，其代表約定的方法集。介面變數可以儲存任意的值，只要該值實現對應的介面方法集。io 包中的 io.Reader 和 io.Writer 介面就是一個眾所周知的例子。

// Reader is the interface that wraps the basic Read method.
type Reader interface {
    Read(p []byte) (n int, err error)
}

// Writer is the interface that wraps the basic Write method.
type Writer interface {
    Write(p []byte) (n int, err error)
}
複製程式碼

任何型別只要實現 Read 或 Write 方法即實現 io.Reader 或 io.Writer 介面。意思就是：介面型別 io.Reader 可以被賦值任意實現 Read 方法的型別。

var r io.Reader
r = os.Stdin
r = bufio.NewReader(r)
r = new(bytes.Buffer)
// and so on
複製程式碼

弄清楚變數 r 內部行為是非常重要的事情，首先 r 的型別永遠是 io.Reader，道理很簡單，Go 是靜態型別語言，r 的型別在編譯時就已經確定為 io.Reader。

一個闡述介面型別的重要例子是空介面 interface{}：

interface{}
複製程式碼

其方法集為空表示任何型別都實現空介面，任何型別的值都可以對其賦值。

有些人說介面是動態型別，這種說法是不對的，它們是靜態型別。一個介面型別變數總是擁有固定的靜態型別，即使在執行時儲存在介面中的值有不同的型別（型別實現介面的方法集）。

我們需要理解這些概念是因為反射和介面密切相關。

介面值

Russ Cox 寫了一篇文章 Go Data Structures: Interfaces 詳細解釋了 Go 語言種的介面值。再次不必重複文章中的概念，下面對文章的簡單總結：

介面型別變數儲存一對值：

  • value：賦值給介面型別變數的實際值；
  • type：實際值的型別資訊。
var r io.Reader
tty, err := os.OpenFile("/dev/tty", os.O_RDWR, 0)
if err != nil {
    return nil, err
}
r = tty
複製程式碼

介面型別變數 r 包含 (value, type) 對 (tty, *os.File)。型別 *os.File 實現的方法不止 Read，即使當前介面只提供 Read 方法，介面中的型別值（the value inside）攜帶所有關於值的型別資訊，因此我們可以實現下面的操作（型別資訊都有自然可以斷言）：

var w io.Writer
w = r.(io.Writer)
複製程式碼

上面的賦值表示式稱為型別斷言，其斷言 r 介面變數內部儲存的 (value, type) 實現 io.Writer 介面，所以我們可以將其賦值給 w。在賦值結束後，w 包含 (tty, *os.File)，與我們之前在 r 中看到的一樣。介面的靜態型別決定了哪些方法可以通過該介面變數呼叫，即使內部儲存的 (value, type) 擁有更大的方法集。

繼續，我們還可以這樣做：

var empty interface{}
empty = w
複製程式碼

我們的空介面 empty 依然會在內部儲存相同的 (tty, *os.File)。這意味著空介面可以儲存任何值並擁有我們需要的所有資訊。

在對空介面賦值時沒有使用型別斷言，因為任何值都滿足空介面，w 顯然實現空介面（方法集是空介面的超集）。而上面的 Reader 轉換的 Writer 則不一樣，我們需要顯式使用型別斷言是因為 Reader 介面不是 Writer 介面的超集。

一個重要的細節是介面內部總是儲存 (value, concrete type)，並不能儲存 (value, interface type)，介面內部並不儲存介面值！

現在我們準備好研究反射了。

第一反射定律

反射從介面值中提取反射物件。

在最基本的概念上，反射只是一種檢測儲存在介面中的 type 和 value 的機制。因此我們需要理解 reflect 包中的兩個型別 Type 和 Value。這兩個型別提供訪問介面變數內部儲存的能力，並提供兩個簡單的函式 TypeOf 和 ValueOf 從介面變數中獲取 Type 和 Value（從 Value 得到 Type 也是一件很簡單的事情，我們暫時保持兩者在概念上的分離）

讓我們從 TypeOf 開始：

package main

import (
    "fmt"
    "reflect"
)

func main() {
    var x float64 = 3.4
    fmt.Println("type:", reflect.TypeOf(x))
}
複製程式碼

輸出：

type: float64
複製程式碼

你也許會想介面在哪裡，看起來只傳遞 float64 型別的 x 變數作為引數給 TypeOf 函式，而不是介面變數。實際上 TypeOf 函式簽名中的引數是空介面，x 會先賦值給空介面，然後作為函式引數傳遞，TypeOf 函式內部處理空介面恢復型別資訊 Type。

// TypeOf returns the reflection Type of the value in the interface{}.
func TypeOf(i interface{}) Type
複製程式碼

ValueOf 函式也是通過類似的方法得到 Value 型別變數。

var x float64 = 3.4
fmt.Println("value:", reflect.ValueOf(x).String())
複製程式碼

輸出：

value: <float64 Value>
複製程式碼

直接呼叫 String 方法是因為在預設情況下 fmt 包直接深入 Value 顯示內部真正的值（3.4）。

Type 和 Value 都包含許多檢測和操縱它們方法，一個重要的方法是 Value 的 Type 方法返回對應的 Type 型別值。另一個重要的方法是兩者都擁有 Kind 方法返回常量基本型別（Uint、Float64、Slice 等）。通常 Value 上的 Int、Float 等函式作用是提取內部儲存的值。

var x float64 = 3.4
v := reflect.ValueOf(x)
fmt.Println("type:", v.Type())
fmt.Println("kind is float64:", v.Kind() == reflect.Float64)
fmt.Println("value:", v.Float())
複製程式碼

輸出：

type: float64
kind is float64: true
value: 3.4
複製程式碼

也有一些 SetInt 和 SetFloat 類方法，使用它們必須理解可設定的概念，下面的第三反射定律詳細談到了這些。

反射庫中有幾個概念值得單獨拿出來講一講。

  1. 為了保持 API 簡單，且 Value 型別的 getter 和 setter 方法集可以操作比較大的值，所有無符號整數都使用 int64 作為引數和返回值。如 Int 方法返回 int64 型別的值，SetInt 使用 int64 型別的引數。
var x uint8 = 'x'
v := reflect.ValueOf(x)
fmt.Println("type:", v.Type())                            // uint8.
fmt.Println("kind is uint8: ", v.Kind() == reflect.Uint8) // true.
x = uint8(v.Uint())                                       // v.Uint returns a uint64.
複製程式碼
  1. Kind 方法返回靜態型別對應的基本型別，例如下面 x 的靜態型別是 MyInt 型別，基本型別是 reflect.Int。
type MyInt int
var x MyInt = 7
v := reflect.ValueOf(x)
複製程式碼

第二反射定律

反射從反射物件中提取介面值。

就像物理反射定律，與第一條定律相反，從反射物件逆向可以得到介面值。

通過 Value 的 Interface 方法可以恢復介面值，實際上這個方法打包 type 和 value 資訊放到空介面中返回。

// Interface returns v's value as an interface{}.
func (v Value) Interface() interface{}
複製程式碼

在結果上我們可以實現：

y := v.Interface().(float64) // y will have type float64.
fmt.Println(y)
複製程式碼

通過反射物件 v 列印 float64 值。

我們可以使用 fmt.Println、fmt.Printf 等函式做得更好，這些函式接收空介面值作為引數，並像上面學到的一樣對這些引數進行解包。因此如果要直接列印 reflect.Value 的內容需要使用 Interface 函式獲取介面值後傳遞。

fmt.Println(v.Interface())
複製程式碼

為什麼不直接使用 fmt.Println(v)？因為 v 是 reflect.Value 型別的值，我們想要的是實際儲存的值。

fmt.Printf("value is %7.1e\n", v.Interface())
複製程式碼

輸出

3.4e+00
複製程式碼

再次強調，這裡不需要使用型別斷言 v.Interface() 到 float64 是因為空介面內部儲存的值和型別在 Printf 函式內部會被恢復。

簡而言之，Interface 方法是 ValueOf 方法的逆方法，除了返回值總是靜態型別 interface{}。

第三反射定律

要修改反射物件，值必須是可設定的。

第三條定律是非常容易使人迷惑的，如果我們從第一條原則開始理解就簡單多了。

下面是一些不能工作但值得學習的程式碼：

var x float64 = 3.4
v := reflect.ValueOf(x)
v.SetFloat(7.1) // Error: will panic.
複製程式碼

如果你允許這些程式碼，會產生 panic 錯誤。

panic: reflect.Value.SetFloat using unaddressable value
複製程式碼

這個錯誤不是說值 7.1 是 not addressable 的，而是說 v 是不可設定的，可設定(settability) 是 Value 的重要屬性，並不是所有 Value 都是可設定的。

CanSet 方法檢測值是否可設定。

var x float64 = 3.4
v := reflect.ValueOf(x)
fmt.Println("settability of v:", v.CanSet())
複製程式碼

輸出：

settability of v: false
複製程式碼

在不可設定的 Value 上呼叫 Set 方法會出錯，那什麼是可設定？

可設定(settability)有一點像地址可達(addressability)，嚴格上說：**這是一個反射物件可以修改實際建立該反射物件的值的屬性，可設定與否取決於反射物件是否持有原始值（指標）。

var x float64 = 3.4
v := reflect.ValueOf(x)
複製程式碼

當我們傳遞一個 x 的拷貝給 reflect.ValueOf，所以引數的空介面值內部持有 x 的拷貝而不是 x 本身。

v.SetFloat(7.1)
複製程式碼

因此，如果這個語句執行成功，也不會更新 x，即使 v 看起來是通過 x 建立的。反而會更新儲存在 Value 中的複製值，真正的 x 並不受影響。上述情況容易產生混亂和困擾，因此在語言層面講這種行為定義為非法的，通過判斷可設定屬性避免這個問題。

如果上面看起來有些奇怪，實際上並非如此，這只是熟悉情境的奇怪包裝罷了（值傳遞和指標傳遞，拿到指標才可以修改原始的值）。

思考傳遞 x 給函式。

f(x)
複製程式碼

我們不會期望 f 能給修改 x 的值，因為我們傳遞給 f 的是 x 值的拷貝，而不是 x 本身。如果我們想要直接修改 x，我們必須傳遞 x 的地址（指標）。

f(&x)
複製程式碼

上面的方式非常簡單和直接，並且反射的工作原理也是一樣的。如果我們想通過反射修改 x，我們必須傳遞指標給 Value。

var x float64 = 3.4
p := reflect.ValueOf(&x) // Note: take the address of x.
fmt.Println("type of p:", p.Type())
fmt.Println("settability of p:", p.CanSet())
複製程式碼

輸出：

type of p: *float64
settability of p: false
複製程式碼

反射物件 p 依然是不可設定的，然而我們並不是想修改 p 指標的值，實際上我們想修改的是 *p 即 p 指向的值。我們需要呼叫 Elem 方法，其間接通過指標取到原始值，並將結果儲存到新的 Value 值中返回。

v := p.Elem()
fmt.Println("settability of v:", v.CanSet())
複製程式碼

現在 v 是可設定的反射物件。

settability of v: true
複製程式碼

自從 v 開始代表 x，我們最終可以使用 v.SetFloat 方法修改 x 的值：

v.SetFloat(7.1)
fmt.Println(v.Interface())
fmt.Println(x)
複製程式碼

輸出：

7.1
7.1
複製程式碼

儘管反射有些難以理解，但反射所做的一切都是語言層面支援的，也許 Value 和 Type 會掩飾所發生的事情。只要保持清醒，關注 Value 在被修改時需要指向某個地址。

Structs

在上面的例子中 v 只是指向一個基本型別，而更通用的問題是修改結構體的欄位，當我們擁有結構體的指標，我們可以修改它的欄位值。

下面是一個簡單的例子用於分析一個結構體值。使用 T 型別的指標建立一個 Value，因此在後續可以修改 t。

宣告並初始化 typeOfT 作為 t 的型別，並通過直接了當的方法 NumField 和 Field 提取出欄位的名字、型別和值。

  • Value 的 Field 還是 Value，並且是可設定的；
  • Type 的 Field 則是 StructField。
type T struct {
    A int
    B string
}
t := T{23, "skidoo"}
s := reflect.ValueOf(&t).Elem()
typeOfT := s.Type()
for i := 0; i < s.NumField(); i++ {
    f := s.Field(i)
    fmt.Printf("%d: %s %s = %v\n", i,
        typeOfT.Field(i).Name, f.Type(), f.Interface())
}
複製程式碼

輸出：

0: A int = 23
1: B string = skidoo
複製程式碼

還有一個關於可設定的知識點：只有以大寫開頭的欄位才是可設定的（可匯出欄位）。

因為 s 包含可設定的反射物件（Elem 獲得原始物件），我們可以修改結構體的欄位。

s.Field(0).SetInt(77)
s.Field(1).SetString("Sunset Strip")
fmt.Println("t is now", t)
複製程式碼

輸出:

t is now {77 Sunset Strip}
複製程式碼

關於

相關文章