本文實(shí)例講述了Go學(xué)習(xí)筆記之反射用法。分享給大家供大家參考，具體如下：
一、類型(Type)
反射（reflect）讓我們能在運(yùn)行期探知對象的類型信息和內(nèi)存結(jié)構(gòu)，這從一定程度上彌(mi)補(bǔ)了靜態(tài)語言在動態(tài)行為上的不足。同時，反射還是實(shí)現(xiàn)元編程的重要手段。
和 C 數(shù)據(jù)結(jié)構(gòu)一樣，Go 對象頭部并沒有類型指針，通過其自身是無法在運(yùn)行期獲知任何類型相關(guān)信息的。反射操作所需要的全部信息都源自接口變量。接口變量除存儲自身類型外，還會保存實(shí)際對象的類型數(shù)據(jù)。
func TypeOf(i interface{}) Type
func ValueOf(i interface{}) Value
這 兩個 反射入口函數(shù)，會將任何傳入的對象轉(zhuǎn)換為接口類型。
在面對類型時，需要區(qū)分 Type 和 Kind。前者表示真實(shí)類型（靜態(tài)類型），后者表示其基礎(chǔ)結(jié)構(gòu)（底層類型）類別 -- 基類型。
復(fù)制代碼 代碼如下:
type X int
func main() {
var a X = 100
t := reflect.TypeOf(a)
fmt.Println(t)
fmt.Println(t.Name(), t.Kind())
}
輸出：
所以在類型判斷上，須選擇正確的方式
復(fù)制代碼 代碼如下:
type X int
type Y int
func main() {
var a, b X = 100, 200
var c Y = 300
ta, tb, tc := reflect.TypeOf(a), reflect.TypeOf(b), reflect.TypeOf(c)
fmt.Println(ta == tb, ta == tc)
fmt.Println(ta.Kind() == tc.Kind())
}
除通過實(shí)際對象獲取類型外，也可直接構(gòu)造一些基礎(chǔ)復(fù)合類型。
復(fù)制代碼 代碼如下:
func main() {
a := reflect.ArrayOf(10, reflect.TypeOf(byte(0)))
m := reflect.MapOf(reflect.TypeOf(""), reflect.TypeOf(0))
fmt.Println(a, m)
}
輸出：
傳入對象 應(yīng)區(qū)分 基類型 和 指針類型，因?yàn)樗鼈儾⒉粚儆谕活愋汀?br />
復(fù)制代碼 代碼如下:
func main() {
x := 100
tx, tp := reflect.TypeOf(x), reflect.TypeOf(x)
fmt.Println(tx, tp, tx == tp)
fmt.Println(tx.Kind(), tp.Kind())
fmt.Println(tx == tp.Elem())
}
輸出：
int *int false
int ptr
true
方法 Elem() 返回 指針、數(shù)組、切片、字典（值）或 通道的 基類型。
復(fù)制代碼 代碼如下:
func main() {
fmt.Println(reflect.TypeOf(map[string]int{}).Elem())
fmt.Println(reflect.TypeOf([]int32{}).Elem())
}
輸出：
只有在獲取 結(jié)構(gòu)體指針 的 基類型 后，才能遍歷它的字段。
復(fù)制代碼 代碼如下:
type user struct {
name string
age int
}
type manager struct {
user
title string
}
func main() {
var m manager
t := reflect.TypeOf(m)
if t.Kind() == reflect.Ptr {
t = t.Elem()
}
for i := 0; i t.NumField(); i++ {
f := t.Field(i)
fmt.Println(f.Name, f.Type, f.Offset)
if f.Anonymous { // 輸出匿名字段結(jié)構(gòu)
for x := 0; x f.Type.NumField(); x++ {
af := f.Type.Field(x)
fmt.Println(" ", af.Name, af.Type)
}
}
}
}
輸出：
user main.user 0
name string
age int
title string 24
對于匿名字段，可用多級索引（按照定義順序）直接訪問。
復(fù)制代碼 代碼如下:
type user struct {
name string
age int
}
type manager struct {
user
title string
}
func main() {
var m manager
t := reflect.TypeOf(m)
name, _ := t.FieldByName("name") // 按名稱查找
fmt.Println(name.Name, name.Type)
age := t.FieldByIndex([]int{0, 1}) // 按多級索引查找
fmt.Println(age.Name, age.Type)
}
輸出：
FieldByName() 不支持多級名稱，如有同名遮蔽，須通過匿名字段二次獲取。
同樣地，輸出方法集時，一樣區(qū)分 基類型 和 指針類型。
復(fù)制代碼 代碼如下:
type A int
type B struct {
A
}
func (A) av() {}
func (*A) ap() {}
func (B) bv() {}
func (*B) bp() {}
func main() {
var b B
t := reflect.TypeOf(b)
s := []reflect.Type{t, t.Elem()}
for _, t2 := range s {
fmt.Println(t2, ":")
for i := 0; i t2.NumMethod(); i++ {
fmt.Println(" ", t2.Method(i))
}
}
}
輸出：
*main.B :
{ap main func(*main.B) func(*main.B) Value> 0}
{av main func(*main.B) func(*main.B) Value> 1}
{bp main func(*main.B) func(*main.B) Value> 2}
{bv main func(*main.B) func(*main.B) Value> 3}
main.B :
{av main func(*main.B) func(*main.B) Value> 0}
{bv main func(*main.B) func(*main.B) Value> 1}
有一點(diǎn)和想象的不同，反射能探知當(dāng)前包或外包的非導(dǎo)出結(jié)構(gòu)成員。
復(fù)制代碼 代碼如下:
import (
"net/http"
"reflect"
"fmt"
)
func main() {
var s http.Server
t := reflect.TypeOf(s)
for i := 0; i t.NumField(); i++ {
fmt.Println(t.Field(i).Name)
}
}
輸出：
Addr
Handler
ReadTimeout
WriteTimeout
TLSConfig
MaxHeaderBytes
TLSNextProto
ConnState
ErrorLog
disableKeepAlives
nextProtoOnce
nextProtoErr
相對 reflect 而言，當(dāng)前包 和 外包 都是“外包”。
可用反射提取 struct tag，還能自動分解。其常用于 ORM 映射，或數(shù)據(jù)格式驗(yàn)證。
復(fù)制代碼 代碼如下:
type user struct {
name string `field:"name" type:"varchar(50)"`
age int `field:"age" type:"int"`
}
func main() {
var u user
t := reflect.TypeOf(u)
for i := 0; i t.NumField(); i++ {
f := t.Field(i)
fmt.Printf("%s: %s %s\n", f.Name, f.Tag.Get("field"), f.Tag.Get("type"))
}
}
輸出：
name: name varchar(50)
age: age int
輔助判斷方法 Implements()、ConvertibleTo、AssignableTo() 都是運(yùn)行期進(jìn)行 動態(tài)調(diào)用 和 賦值 所必需的。
復(fù)制代碼 代碼如下:
type X int
func (X) String() string {
return ""
}
func main() {
var a X
t := reflect.TypeOf(a)
// Implements 不能直接使用類型作為參數(shù)，導(dǎo)致這種用法非常別扭
st := reflect.TypeOf((*fmt.Stringer)(nil)).Elem()
fmt.Println(t.Implements(st))
it := reflect.TypeOf(0)
fmt.Println(t.ConvertibleTo(it))
fmt.Println(t.AssignableTo(st), t.AssignableTo(it))
}
輸出：
二、值(Value)
和 Type 獲取類型信息不同，Value 專注于對象實(shí)例數(shù)據(jù)讀寫。
在前面章節(jié)曾提到過，接口變量會復(fù)制對象，且是 unaddressable 的，所以要想修改目標(biāo)對象，就必須使用指針。
復(fù)制代碼 代碼如下:
func main() {
a := 100
va, vp := reflect.ValueOf(a), reflect.ValueOf(a).Elem()
fmt.Println(va.CanAddr(), va.CanSet())
fmt.Println(vp.CanAddr(), vp.CanSet())
}
輸出：
就算傳入指針，一樣需要通過 Elem() 獲取目標(biāo)對象。因?yàn)楸唤涌诖鎯Φ闹羔槺旧硎遣荒軐ぶ泛瓦M(jìn)行設(shè)置操作的。
注意，不能對非導(dǎo)出字段直接進(jìn)行設(shè)置操作，無論是當(dāng)前包還是外包。
復(fù)制代碼 代碼如下:
type User struct {
Name string
code int
}
func main() {
p := new(User)
v := reflect.ValueOf(p).Elem()
name := v.FieldByName("Name")
code := v.FieldByName("code")
fmt.Printf("name: canaddr = %v, canset = %v\n", name.CanAddr(), name.CanSet())
fmt.Printf("code: canaddr = %v, canset = %v\n", code.CanAddr(), code.CanSet())
if name.CanSet() {
name.SetString("Tom")
}
if code.CanAddr() {
*(*int)(unsafe.Pointer(code.UnsafeAddr())) = 100
}
fmt.Printf("%+v\n", *p)
}
輸出：
name: canaddr = true, canset = true
code: canaddr = true, canset = false
{Name:Tom code:100}
Value.Pointer 和 Value.Int 等方法類型，將 Value.data 存儲的數(shù)據(jù)轉(zhuǎn)換為指針，目標(biāo)必須是指針類型。而 UnsafeAddr 返回任何 CanAddr Value.data 地址（相當(dāng)于 取地址操作），比如 Elem() 后的 Value，以及字段成員地址。
以結(jié)構(gòu)體里的指針類型字段為例，Pointer 返回該字段所保存的地址，而 UnsafeAddr 返回該字段自身的地址（結(jié)構(gòu)對象地址 + 偏移量）。
可通過 Interface 方法進(jìn)行類型 推薦 和 轉(zhuǎn)換。
復(fù)制代碼 代碼如下:
func main() {
type user struct {
Name string
Age int
}
u := user{
"q.yuhen",
60,
}
v := reflect.ValueOf(u)
if !v.CanInterface() {
println("CanInterface: fail.")
return
}
p, ok := v.Interface().(*user)
if !ok {
println("Interface: fail.")
return
}
p.Age++
fmt.Printf("%+v\n", u)
}
輸出：
也可以直接使用 Value.Int、Bool 等方法進(jìn)行類型轉(zhuǎn)換，但失敗時會引發(fā) pani，且不支持 ok-idiom。
復(fù)合類型對象設(shè)置示例：
復(fù)制代碼 代碼如下:
func main() {
c := make(chan int, 4)
v := reflect.ValueOf(c)
if v.TrySend(reflect.ValueOf(100)) {
fmt.Println(v.TryRecv())
}
}
輸出：
接口有兩種 nil 狀態(tài)，這一直是個潛在麻煩。解決方法是用 IsNil() 判斷值是否為 nil。
復(fù)制代碼 代碼如下:
func main() {
var a interface{} = nil
var b interface{} = (*int)(nil)
fmt.Println(a == nil)
fmt.Println(b == nil, reflect.ValueOf(b).IsNil())
}
輸出：
也可用 unsafe 轉(zhuǎn)換后直接判斷 iface.data 是否為零值。
復(fù)制代碼 代碼如下:
func main() {
var b interface{} = (*int)(nil)
iface := (*[2]uintptr)(unsafe.Pointer(b))
fmt.Println(iface, iface[1] == 0)
}
輸出：
讓人很無奈的是，Value 里的某些方法并未實(shí)現(xiàn) ok-idom 或返回 error，所以得自行判斷返回的是否為 Zero Value。
復(fù)制代碼 代碼如下:
func main() {
v := reflect.ValueOf(struct {name string}{})
println(v.FieldByName("name").IsValid())
println(v.FieldByName("xxx").IsValid())
}
輸出：
三、方法
動態(tài)調(diào)用方法，談不上有多麻煩。只須按 In 列表準(zhǔn)備好所需參數(shù)即可。
復(fù)制代碼 代碼如下:
type X struct {}
func (X) Test(x, y int) (int, error) {
return x + y, fmt.Errorf("err: %d", x + y)
}
func main() {
var a X
v := reflect.ValueOf(a)
m := v.MethodByName("Test")
in := []reflect.Value{
reflect.ValueOf(1),
reflect.ValueOf(2),
}
out := m.Call(in)
for _, v := range out {
fmt.Println(v)
}
}
輸出：
對于變參來說，用 CallSlice() 要更方便一些。
復(fù)制代碼 代碼如下:
type X struct {}
func (X) Format(s string, a ...interface{}) string {
return fmt.Sprintf(s, a...)
}
func main() {
var a X
v := reflect.ValueOf(a)
m := v.MethodByName("Format")
out := m.Call([]reflect.Value{
reflect.ValueOf("%s = %d"), // 所有參數(shù)都須處理
reflect.ValueOf("x"),
reflect.ValueOf(100),
})
fmt.Println(out)
out = m.CallSlice([]reflect.Value{
reflect.ValueOf("%s = %d"),
reflect.ValueOf([]interface{}{"x", 100}),
})
fmt.Println(out)
}
輸出：
無法調(diào)用非導(dǎo)出方法，甚至無法獲取有效地址。
四、構(gòu)建
反射庫提供了內(nèi)置函數(shù) make() 和 new() 的對應(yīng)操作，其中最有意思的就是 MakeFunc()?？捎盟鼘?shí)現(xiàn)通用模板，適應(yīng)不同數(shù)據(jù)類型。
復(fù)制代碼 代碼如下:
// 通用算法函數(shù)
func add(args []reflect.Value) (results []reflect.Value) {
if len(args) == 0 {
return nil
}
var ret reflect.Value
switch args[0].Kind() {
case reflect.Int:
n := 0
for _, a := range args {
n += int(a.Int())
}
ret = reflect.ValueOf(n)
case reflect.String:
ss := make([]string, 0, len(args))
for _, s := range args {
ss = append(ss, s.String())
}
ret = reflect.ValueOf(strings.Join(ss, ""))
}
results = append(results, ret)
return
}
// 將函數(shù)指針參數(shù)指向通用算法函數(shù)
func makeAdd(fptr interface{}) {
fn := reflect.ValueOf(fptr).Elem()
v := reflect.MakeFunc(fn.Type(), add) // 這是關(guān)鍵
fn.Set(v) // 指向通用算法函數(shù)
}
func main() {
var intAdd func(x, y int) int
var strAdd func(a, b string) string
makeAdd(intAdd)
makeAdd(strAdd)
println(intAdd(100, 200))
println(strAdd("hello, ", "world!"))
}
輸出：
如果語言支持泛型，自然不需要這么折騰
希望本文所述對大家Go語言程序設(shè)計有所幫助。
您可能感興趣的文章:- golang之反射和斷言的具體使用
- 詳解Golang利用反射reflect動態(tài)調(diào)用方法
- 淺談Go語言中的結(jié)構(gòu)體struct & 接口Interface & 反射
- Go語言中反射的正確使用
- 談?wù)凣o語言的反射三定律
- go語言通過反射獲取和設(shè)置結(jié)構(gòu)體字段值的方法
- Go語言中使用反射的方法
- 圖文詳解go語言反射實(shí)現(xiàn)原理
