建站
咨詢
售后
建站咨詢
新聞中心
反射是眾多編程語言中的一個(gè)非常實(shí)用的功能，它是一種能夠自描述、自控制的應(yīng)用，Go語言也對反射提供了友好的支持。
Go語言中使用反射可以在編譯時(shí)不知道類型的情況下更新變量，在運(yùn)行時(shí)查看值、調(diào)用方法以及直接對他們的布局進(jìn)行操作。
由于反射是建立在類型系統(tǒng)（type system）上的，所以我們先來復(fù)習(xí)一下Go語言中的類型。
Go語言中的類型
Go語言是一門靜態(tài)類型的語言，每個(gè)變量都有一個(gè)靜態(tài)類型，類型在編譯的時(shí)候確定下來。
type MyInt int
var i int
var j MyInt
變量 i 的類型是 int，變量 j 的類型是 MyInt，雖然它們有著相同的基本類型，但靜態(tài)類型卻不一樣，在沒有類型轉(zhuǎn)換的情況下，它們之間無法互相賦值。
接口是一個(gè)重要的類型，它意味著一個(gè)確定的方法集合，一個(gè)接口變量可以存儲任何實(shí)現(xiàn)了接口的方法的具體值（除了接口本身），例如 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)
}
如果一個(gè)類型聲明實(shí)現(xiàn)了 Reader（或 Writer）方法，那么它便實(shí)現(xiàn)了 io.Reader（或 io.Writer），這意味著一個(gè) io.Reader 的變量可以持有任何一個(gè)實(shí)現(xiàn)了 Read 方法的的類型的值。
var r io.Reader
r = os.Stdin
r = bufio.NewReader(r)
r = new(bytes.Buffer)
// and so on
必須要弄清楚的一點(diǎn)是，不管變量 r 中的具體值是什么，r 的類型永遠(yuǎn)是 io.Reader，由于Go語言是靜態(tài)類型的，r 的靜態(tài)類型就是 io.Reader。
在接口類型中有一個(gè)極為重要的例子——空接口：
interface{}
它表示了一個(gè)空的方法集，一切值都可以滿足它，因?yàn)樗鼈兌加辛阒祷蚍椒ā?/p>
有人說Go語言的接口是動態(tài)類型，這是錯(cuò)誤的，它們都是靜態(tài)類型，雖然在運(yùn)行時(shí)中，接口變量存儲的值也許會變，但接口變量的類型是不會變的。我們必須精確地了解這些，因?yàn)榉瓷渑c接口是密切相關(guān)的。
關(guān)于接口我們就介紹到這里，下面我們看看Go語言的反射三定律。
反射第一定律：反射可以將“接口類型變量”轉(zhuǎn)換為“反射類型對象”
注：這里反射類型指 reflect.Type 和 reflect.Value。
從使用方法上來講，反射提供了一種機(jī)制，允許程序在運(yùn)行時(shí)檢查接口變量內(nèi)部存儲的 (value, type) 對。
在最開始，我們先了解下 reflect 包的兩種類型 Type 和 Value，這兩種類型使訪問接口內(nèi)的數(shù)據(jù)成為可能，它們對應(yīng)兩個(gè)簡單的方法，分別是 reflect.TypeOf 和 reflect.ValueOf，分別用來讀取接口變量的 reflect.Type 和 reflect.Value 部分。
當(dāng)然，從 reflect.Value 也很容易獲取到 reflect.Type，目前我們先將它們分開。
首先，我們下看 reflect.TypeOf：
package main
import (
"fmt"
"reflect"
)
func main() {
var x float64 = 3.4
fmt.Println("type:", reflect.TypeOf(x))
}運(yùn)行結(jié)果如下：
type: float64
大家可能會疑惑，為什么沒看到接口？這段代碼看起來只是把一個(gè) float64 類型的變量 x 傳遞給 reflect.TypeOf 并沒有傳遞接口。其實(shí)在 reflect.TypeOf 的函數(shù)簽名里包含一個(gè)空接口：
// TypeOf returns the reflection Type of the value in the interface{}.
func TypeOf(i interface{}) Type
我們調(diào)用 reflect.TypeOf(x) 時(shí)，x 被存儲在一個(gè)空接口變量中被傳遞過去，然后 reflect.TypeOf 對空接口變量進(jìn)行拆解，恢復(fù)其類型信息。
函數(shù) reflect.ValueOf 也會對底層的值進(jìn)行恢復(fù)：
package main
import (
"fmt"
"reflect"
)
func main() {
var x float64 = 3.4
fmt.Println("value:", reflect.ValueOf(x))
}運(yùn)行結(jié)果如下：
value: 3.4
類型 reflect.Type 和 reflect.Value 都有很多方法，我們可以檢查和使用它們，這里我們舉幾個(gè)例子。
類型 reflect.Value 有一個(gè)方法 Type()，它會返回一個(gè) reflect.Type 類型的對象。
Type 和 Value 都有一個(gè)名為 Kind 的方法，它會返回一個(gè)常量，表示底層數(shù)據(jù)的類型，常見值有：Uint、Float64、Slice 等。
Value 類型也有一些類似于 Int、Float 的方法，用來提取底層的數(shù)據(jù)：
- Int 方法用來提取 int64
- Float 方法用來提取 float64，示例代碼如下：
package main
import (
"fmt"
"reflect"
)
func main() {
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())
}運(yùn)行結(jié)果如下：
type: float64
kind is float64: true
value: 3.4
還有一些用來修改數(shù)據(jù)的方法，比如 SetInt、SetFloat。在介紹它們之前，我們要先理解“可修改性”（settability），這一特性會在下面進(jìn)行詳細(xì)說明。
反射庫提供了很多值得列出來單獨(dú)討論的屬性，下面就來介紹一下。
首先是介紹下 Value 的 getter 和 setter 方法，為了保證 API 的精簡，這兩個(gè)方法操作的是某一組類型范圍最大的那個(gè)。比如，處理任何含符號整型數(shù)，都使用 int64，也就是說 Value 類型的 Int 方法返回值為 int64 類型，SetInt 方法接收的參數(shù)類型也是 int64 類型。實(shí)際使用時(shí)，可能需要轉(zhuǎn)化為實(shí)際的類型：
package main
import (
"fmt"
"reflect"
)
func main() {
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.
}運(yùn)行結(jié)果如下：
type: uint8
kind is uint8: true
其次，反射對象的 Kind 方法描述的是基礎(chǔ)類型，而不是靜態(tài)類型。如果一個(gè)反射對象包含了用戶定義類型的值，如下所示：
type MyInt int
var x MyInt = 7
v := reflect.ValueOf(x)
上面的代碼中，雖然變量 v 的靜態(tài)類型是 MyInt，而不是 int，但 Kind 方法仍然會返回 reflect.Int。換句話說 Kind 方法不會像 Type 方法一樣區(qū)分 MyInt 和 int。
反射第二定律：反射可以將“反射類型對象”轉(zhuǎn)換為“接口類型變量”
和物理學(xué)中的反射類似，Go語言中的反射也能創(chuàng)造自己反面類型的對象。
根據(jù)一個(gè) reflect.Value 類型的變量，我們可以使用 Interface 方法恢復(fù)其接口類型的值。事實(shí)上，這個(gè)方法會把 type 和 value 信息打包并填充到一個(gè)接口變量中，然后返回。
其函數(shù)聲明如下：
// Interface returns v's value as an interface{}.
func (v Value) Interface() interface{}
然后，我們可以通過斷言，恢復(fù)底層的具體值：
y := v.Interface().(float64) // y will have type float64.
fmt.Println(y)
上面這段代碼會打印出一個(gè) float64 類型的值，也就是反射類型變量 v 所代表的值。
事實(shí)上，我們可以更好地利用這一特性，標(biāo)準(zhǔn)庫中的 fmt.Println 和 fmt.Printf 等函數(shù)都接收空接口變量作為參數(shù)，fmt 包內(nèi)部會對接口變量進(jìn)行拆包，因此 fmt 包的打印函數(shù)在打印 reflect.Value 類型變量的數(shù)據(jù)時(shí)，只需要把 Interface 方法的結(jié)果傳給格式化打印程序：
fmt.Println(v.Interface())
為什么不直接使用 fmt.Println(v)？因?yàn)?v 的類型是 reflect.Value，我們需要的是它的具體值，由于值的類型是 float64，我們也可以用浮點(diǎn)格式化打印它：
fmt.Printf("value is %7.1e\n", v.Interface())
運(yùn)行結(jié)果如下：
3.4e+00
同樣，這次也不需要對 v.Interface() 的結(jié)果進(jìn)行類型斷言，空接口值內(nèi)部包含了具體值的類型信息，Printf 函數(shù)會恢復(fù)類型信息。
簡單來說 Interface 方法和 ValueOf 函數(shù)作用恰好相反，唯一一點(diǎn)是，返回值的靜態(tài)類型是 interface{}。
Go的反射機(jī)制可以將“接口類型的變量”轉(zhuǎn)換為“反射類型的對象”，然后再將“反射類型對象”轉(zhuǎn)換過去。
反射第三定律：如果要修改“反射類型對象”其值必須是“可寫的”
這條定律很微妙，也很容易讓人迷惑，但是如果從第一條定律開始看，應(yīng)該比較容易理解。
下面這段代碼雖然不能正常工作，但是非常值得研究：
var x float64 = 3.4
v := reflect.ValueOf(x)
v.SetFloat(7.1) // Error: will panic
如果運(yùn)行這段代碼，它會拋出一個(gè)奇怪的異常：
panic: reflect: reflect.flag.mustBeAssignable using unaddressable value
這里問題不在于值7.1 不能被尋址，而是因?yàn)樽兞?v 是“不可寫的”，“可寫性”是反射類型變量的一個(gè)屬性，但不是所有的反射類型變量都擁有這個(gè)屬性。
我們可以通過 CanSet 方法檢查一個(gè) reflect.Value 類型變量的“可寫性”，對于上面的例子，可以這樣寫：
package main
import (
"fmt"
"reflect"
)
func main() {
var x float64 = 3.4
v := reflect.ValueOf(x)
fmt.Println("settability of v:", v.CanSet())
} 運(yùn)行結(jié)果如下：
settability of v: false
對于一個(gè)不具有“可寫性”的 Value 類型變量，調(diào)用 Set 方法會報(bào)出錯(cuò)誤。
首先我們要弄清楚什么是“可寫性”，“可寫性”有些類似于尋址能力，但是更嚴(yán)格，它是反射類型變量的一種屬性，賦予該變量修改底層存儲數(shù)據(jù)的能力?！翱蓪懶浴弊罱K是由一個(gè)反射對象是否存儲了原始值而決定的。
示例代碼如下：
var x float64 = 3.4
v := reflect.ValueOf(x)
這里我們傳遞給 reflect.ValueOf 函數(shù)的是變量 x 的一個(gè)拷貝，而非 x 本身，想象一下如果下面這行代碼能夠成功執(zhí)行：
v.SetFloat(7.1)
如果這行代碼能夠成功執(zhí)行，它不會更新 x，雖然看起來變量 v 是根據(jù) x 創(chuàng)建的，相反它會更新 x 存在于反射對象 v 內(nèi)部的一個(gè)拷貝，而變量 x 本身完全不受影響。這會造成迷惑，并且沒有任何意義，所以是不合法的?！翱蓪懶浴本褪菫榱吮苊膺@個(gè)問題而設(shè)計(jì)的。
這看起來很詭異，事實(shí)上并非如此，而且類似的情況很常見。考慮下面這行代碼：
f(x)
代碼中，我們把變量 x 的一個(gè)拷貝傳遞給函數(shù)，因此不期望它會改變 x 的值。如果期望函數(shù) f 能夠修改變量 x，我們必須傳遞 x 的地址（即指向 x 的指針）給函數(shù) f，如下所示：
f(&x)
反射的工作機(jī)制與此相同，如果想通過反射修改變量 x，就要把想要修改的變量的指針傳遞給反射庫。
首先，像通常一樣初始化變量 x，然后創(chuàng)建一個(gè)指向它的反射對象，命名為 p：
package main
import (
"fmt"
"reflect"
)
func main() {
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())
} 運(yùn)行結(jié)果如下：
type of p: *float64
settability of p: false
反射對象 p 是不可寫的，但是我們也不像修改 p，事實(shí)上我們要修改的是 *p。為了得到 p 指向的數(shù)據(jù)，可以調(diào)用 Value 類型的 Elem 方法。Elem 方法能夠?qū)χ羔樳M(jìn)行“解引用”，然后將結(jié)果存儲到反射 Value 類型對象 v 中：
package main
import (
"fmt"
"reflect"
)
func main() {
var x float64 = 3.4
p := reflect.ValueOf(&x) // Note: take the address of x.
v := p.Elem()
fmt.Println("settability of v:", v.CanSet())
} 運(yùn)行結(jié)果如下：
settability of v: true
由于變量 v 代表 x， 因此我們可以使用 v.SetFloat 修改 x 的值：
package main
import (
"fmt"
"reflect"
)
func main() {
var x float64 = 3.4
p := reflect.ValueOf(&x) // Note: take the address of x.
v := p.Elem()
v.SetFloat(7.1)
fmt.Println(v.Interface())
fmt.Println(x)
}運(yùn)行結(jié)果如下：
7.1
7.1
反射不太容易理解，reflect.Type 和 reflect.Value 會混淆正在執(zhí)行的程序，但是它做的事情正是編程語言做的事情。只需要記住：只要反射對象要修改它們表示的對象，就必須獲取它們表示的對象的地址。
結(jié)構(gòu)體
我們一般使用反射修改結(jié)構(gòu)體的字段，只要有結(jié)構(gòu)體的指針，我們就可以修改它的字段。
下面是一個(gè)解析結(jié)構(gòu)體變量 t 的例子，用結(jié)構(gòu)體的地址創(chuàng)建反射變量，再修改它。然后我們對它的類型設(shè)置了 typeOfT，并用調(diào)用簡單的方法迭代字段。
需要注意的是，我們從結(jié)構(gòu)體的類型中提取了字段的名字，但每個(gè)字段本身是正常的 reflect.Value 對象。
package main
import (
"fmt"
"reflect"
)
func main() {
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())
}
}運(yùn)行結(jié)果如下：
0: A int = 23
1: B string = skidoo
T 字段名之所以大寫，是因?yàn)榻Y(jié)構(gòu)體中只有可導(dǎo)出的字段是“可設(shè)置”的。
因?yàn)?s 包含了一個(gè)可設(shè)置的反射對象，我們可以修改結(jié)構(gòu)體字段：
package main
import (
"fmt"
"reflect"
)
func main() {
type T struct {
A int
B string
}
t := T{23, "skidoo"}
s := reflect.ValueOf(&t).Elem()
s.Field(0).SetInt(77)
s.Field(1).SetString("Sunset Strip")
fmt.Println("t is now", t)
}運(yùn)行結(jié)果如下：
t is now {77 Sunset Strip}
如果我們修改了程序讓 s 由 t（而不是 &t）創(chuàng)建，程序就會在調(diào)用 SetInt 和 SetString 的地方失敗，因?yàn)?t 的字段是不可設(shè)置的。
總結(jié)
反射規(guī)則可以總結(jié)為如下幾條：
- 反射可以將“接口類型變量”轉(zhuǎn)換為“反射類型對象”；
- 反射可以將“反射類型對象”轉(zhuǎn)換為“接口類型變量”；
- 如果要修改“反射類型對象”，其值必須是“可寫的”。
分享文章：創(chuàng)新互聯(lián)GO教程:Go語言反射規(guī)則淺析
網(wǎng)站路徑：http://www.5511xx.com/article/dhheosd.html
