Go語言通過反射實(shí)現(xiàn)獲取各種類型變量的值
更新時(shí)間：2023年07月24日 09:07:36 作者：242030
反射是程序在運(yùn)行期間獲取變量的類型和值、或者執(zhí)行變量的方法的能力，這篇文章主要為大家講講Go語言通過反射獲取各種類型變量值的方法，需要的可以參考下
反射是程序在運(yùn)行期間獲取變量的類型和值、或者執(zhí)行變量的方法的能力。
1、什么是反射
反射是程序在運(yùn)行期間獲取變量的類型和值、或者執(zhí)行變量的方法的能力。
Golang 反射包中有兩對(duì)非常重要的函數(shù)和類型，兩個(gè)函數(shù)分別是：
reflect.TypeOf 能獲取類型信息 reflect.Type；
reflect.ValueOf 能獲取數(shù)據(jù)的運(yùn)行時(shí)表示 reflect.Value；
2、reflect.Type
Golang 是一門靜態(tài)類型的語言，反射是建立在類型之上的。
通過 reflect.TypeOf() 函數(shù)可以獲得任意值的類型信息。
2.1 類型Type和種類Kind
諸如 int32, slice, map 以及通過 type 關(guān)鍵詞自定義的類型種類
Kind 可以理解為類型的具體分類，如 int32、type MyInt32 int32 是兩種不同類型，但都屬于 int32 這個(gè)種類。
使用 reflect.TypeOf() 獲取變量類型以及種類。
package main
import (
"fmt"
"reflect"
)
func main() {
type MyInt32 int32
a := MyInt32(1)
b := int32(1)
// reflect.TypeOf(a):main.MyInt32 Kind:int32
fmt.Printf("reflect.TypeOf(a):%v Kind:%v\n", reflect.TypeOf(a), reflect.TypeOf(a).Kind())
// reflect.TypeOf(b):int32 Kind:int32
fmt.Printf("reflect.TypeOf(b):%v Kind:%v\n", reflect.TypeOf(b), reflect.TypeOf(b).Kind())
}從代碼輸出可以看出 int32、type MyInt32 int32 是兩種不同類型，但都屬于 int32 這個(gè)種類。
種類定義點(diǎn)擊查看：
// A Kind represents the specific kind of type that a Type represents. // The zero Kind is not a valid kind. type Kind uint const ( Invalid Kind = iota Bool Int Int8 Int16 Int32 Int64 Uint Uint8 Uint16 Uint32 Uint64 Uintptr Float32 Float64 Complex64 Complex128 Array Chan Func Interface Map Pointer Slice String Struct UnsafePointer )
2.2 引用指向元素的類型
// Elem returns a type's element type. // It panics if the type's Kind is not Array, Chan, Map, Pointer, or Slice. Elem() Type
部分情況我們需要獲取指針指向元素的類型、或者 slice 元素的類型，可以 reflect.Elem() 函數(shù)獲取。
package main
import (
"fmt"
"reflect"
)
type myStruct struct {
}
func main() {
a := &myStruct{}
typeA := reflect.TypeOf(a)
// TypeOf(a):*main.myStruct Kind:ptr
fmt.Printf("TypeOf(a):%v Kind:%v\n", typeA, typeA.Kind())
// TypeOf(a).Elem():main.myStruct Elem().Kind:struct
fmt.Printf("TypeOf(a).Elem():%v Elem().Kind:%v\n", typeA.Elem(), typeA.Elem().Kind())
s := []int64{}
typeS := reflect.TypeOf(s)
// TypeOf(s):[]int64 Kind:slice
fmt.Printf("TypeOf(s):%v Kind:%v\n", typeS, typeS.Kind())
// TypeOf(s).Elem():int64 Elem().Kind:int64
fmt.Printf("TypeOf(s).Elem():%v Elem().Kind:%v\n", typeS.Elem(), typeS.Elem().Kind())
}從代碼輸出可以看出，通過 reflect.Elem() 函數(shù)可以獲取引用指向數(shù)據(jù)的類型。
2.3 結(jié)構(gòu)體成員類型
通過 NumField 獲取成員數(shù)量，F(xiàn)ield 通過下標(biāo)訪問成員的類型信息 StructField，包括成員名稱、類型、Tag 信息等。
package main
import (
"fmt"
"reflect"
)
type secStruct struct {
Cnt []int64
}
type myStruct struct {
Num int `json:"num_json" orm:"column:num_orm"`
Desc string `json:"desc_json" orm:"column:desc_orm"`
Child secStruct
}
func main() {
s := myStruct{}
typeS := reflect.TypeOf(s)
// 成員數(shù)量
// NumField:3
fmt.Printf("NumField:%v \n", typeS.NumField())
// 每個(gè)成員的信息 包括名稱、類型、Tag
for i := 0; i < typeS.NumField(); i++ {
// 通過下標(biāo)訪問成員
// Field(0):{Name:Num PkgPath: Type:int Tag:json:"num_json" orm:"column:num_orm" Offset:0 Index:[0] Anonymous:false}
// Field(1):{Name:Desc PkgPath: Type:string Tag:json:"desc_json" orm:"column:desc_orm" Offset:8 Index:[1] Anonymous:false}
// Field(2):{Name:Child PkgPath: Type:main.secStruct Tag: Offset:24 Index:[2] Anonymous:false}
fmt.Printf("Field(%v):%+v\n", i, typeS.Field(i))
}
// 通過名稱訪問成員
field, ok := typeS.FieldByName("Num")
// FieldByName("Num") ok:true field:{Name:Num PkgPath: Type:int Tag:json:"num_json" orm:"column:num_orm" Offset:0 Index:[0] Anonymous:false}
fmt.Printf("FieldByName(\"Num\") ok:%v field:%+v\n", ok, field)
// 獲取tag值
// json tag val:num_json
fmt.Printf("json tag val:%+v\n", field.Tag.Get("json"))
if value, ok := field.Tag.Lookup("orm"); ok {
// rm tag val:column:num_orm
fmt.Printf("orm tag val:%+v\n", value)
}
// 獲取嵌套結(jié)構(gòu)體的字段
// Cnt field:{Name:Child PkgPath: Type:main.secStruct Tag: Offset:24 Index:[2] Anonymous:false}
fmt.Printf("Cnt field:%+v\n", typeS.FieldByIndex([]int{2}))
// Cnt field:{Name:Cnt PkgPath: Type:[]int64 Tag: Offset:0 Index:[0] Anonymous:false}
fmt.Printf("Cnt field:%+v\n", typeS.FieldByIndex([]int{2, 0}))
}3、reflect.Value
通過 reflect.ValueOf 獲取變量值、值類型，種類為 Array, Chan, Map, Slice 或 String，可通過 Len() 獲取長(zhǎng)度。
package main
import (
"fmt"
"reflect"
)
func main() {
b := int32(1)
valueB := reflect.ValueOf(b)
// reflect.TypeOf(b):1 Kind:int32
fmt.Printf("reflect.TypeOf(b):%v Kind:%v\n", valueB, valueB.Kind())
s := "abcdefg"
valueS := reflect.ValueOf(s)
// reflect.TypeOf(s):abcdefg Kind:string Len:7
fmt.Printf("reflect.TypeOf(s):%v Kind:%v Len:%v\n", valueS, valueS.Kind(), valueS.Len())
}3.1 結(jié)構(gòu)體的成員的值
和 2.3 結(jié)構(gòu)體成員類型獲取結(jié)構(gòu)體成員類型類似，reflect 提供了 NumField 獲取成員數(shù)量，F(xiàn)ield 通過下標(biāo)訪問成員的值。
package main
import (
"fmt"
"reflect"
)
type secStruct struct {
Cnt []int64
}
type myStruct struct {
Num int `json:"num_json" orm:"column:num_orm"`
Desc string `json:"desc_json" orm:"column:desc_orm"`
Child secStruct
}
func main() {
s := myStruct{
Num: 100,
Desc: "desc",
Child: secStruct{[]int64{1, 2, 3}},
}
valueS := reflect.ValueOf(s)
// 成員數(shù)量
// NumField:3
fmt.Printf("NumField:%v \n", valueS.NumField())
// 每個(gè)成員的值
for i := 0; i < valueS.NumField(); i++ {
// 通過下標(biāo)訪問成員
// value(0):100
// value(1):desc
// value(2):{Cnt:[1 2 3]}
fmt.Printf("value(%v):%+v\n", i, valueS.Field(i))
}
// 通過名稱訪問成員
value := valueS.FieldByName("Num")
// FieldByName("Num") value:100
fmt.Printf("FieldByName(\"Num\") value:%v\n", value)
// 獲取嵌套結(jié)構(gòu)體的字段
// Cnt field:[1 2 3]
fmt.Printf("Cnt field:%+v\n", valueS.FieldByIndex([]int{2, 0}))
}3.2 遍歷array、slice
通過 func (v Value) Index(i int) Value 可以通過下標(biāo)來訪問 Array，Slice，或者 String 各個(gè)元素的值。
package main
import (
"fmt"
"reflect"
)
func main() {
s := []int64{1, 2, 3, 4, 5, 6}
valueS := reflect.ValueOf(s)
// ValueOf(s):[1 2 3 4 5 6] Kind:slice Len:6
fmt.Printf("ValueOf(s):%v Kind:%v Len:%v\n", valueS, valueS.Kind(), valueS.Len())
for i := 0; i < valueS.Len(); i++ {
// valueS.Index(0):1
// valueS.Index(1):2
// valueS.Index(2):3
// valueS.Index(3):4
// valueS.Index(4):5
// valueS.Index(5):6
fmt.Printf("valueS.Index(%v):%v\n", i, valueS.Index(i))
}
}3.3 遍歷map
reflect 有兩種方法遍歷 map
- 通過迭代器 MapIter 遍歷 map
- 先獲取 map 的所有 key，再通過 key 獲取對(duì)應(yīng)的 value
package main
import (
"fmt"
"reflect"
)
func main() {
m := map[int]string{
1: "1",
2: "2",
3: "3",
}
valueM := reflect.ValueOf(m)
// 迭代器訪問
iter := valueM.MapRange()
for iter.Next() {
// key:1 val:1
// key:2 val:2
// key:3 val:3
fmt.Printf("key:%v val:%v\n", iter.Key(), iter.Value())
}
// ------
fmt.Println("------")
// 通過key訪問
keys := valueM.MapKeys()
for i := 0; i < len(keys); i++ {
// key:1 val:1
// key:2 val:2
// key:3 val:3
fmt.Printf("key:%v val:%v\n", keys[i], valueM.MapIndex(keys[i]))
}
}4、反射的三大定律
反射的兩個(gè)基礎(chǔ)函數(shù)定義：
- 獲取類型 func TypeOf(i any) Type
- 獲取值 func ValueOf(i any) Value
其中，any 是 interface{} 的別名。
interface{} 是不包含任何方法簽名的空接口，任何類型都實(shí)現(xiàn)了空接口。
因此，interface{} 可以承載任何變量的 (value, concrete type)信息。
4.1 從interface到反射對(duì)象
interface{} 承載變量的 (value, concrete type) 信息，通過反射暴露方法來訪問 interface{} 的值和類型。
可以簡(jiǎn)單理解為 interface{} 的值和信息傳遞到 reflect.Type 和 reflect.Value，方便獲取。
4.2 從反射對(duì)象到interface
可以通過函數(shù) func (v Value) Interface() (i any) 將反射對(duì)象轉(zhuǎn)換為 interface{}，是 func ValueOf(i any) Value的反向操作。
package main
import (
"fmt"
"reflect"
)
func main() {
a := int32(10)
valueA := reflect.ValueOf(a)
// ValueOf(a):10
fmt.Printf("ValueOf(a):%v\n", valueA)
// Interface():10
fmt.Printf("Interface():%v\n", valueA.Interface())
ai, ok := valueA.Interface().(int32)
// ok:true val:10
fmt.Printf("ok:%v val:%v\n", ok, ai)
}4.3 通過反射修改對(duì)象，該對(duì)象值必須是可修改的
reflect提供 func (v Value) CanSet() bool 判斷對(duì)象值是否修改，通過 func (v Value) Set(x Value) 修改對(duì)象值。
package main
import (
"fmt"
"reflect"
)
func main() {
a := int32(10)
valueA := reflect.ValueOf(a)
// valueA :false
fmt.Printf("valueA :%v\n", valueA.CanSet())
b := int32(100)
valuePtrB := reflect.ValueOf(&b)
// valuePtrB:false Elem:true
fmt.Printf("valuePtrB:%v Elem:%v\n", valuePtrB.CanSet(), valuePtrB.Elem().CanSet())
valuePtrB.Elem().Set(reflect.ValueOf(int32(200)))
// b:200 Elem:200
fmt.Printf("b:%v Elem:%v\n", b, valuePtrB.Elem())
}到此這篇關(guān)于Go語言通過反射實(shí)現(xiàn)獲取各種類型變量的值的文章就介紹到這了,更多相關(guān)Go反射獲取變量值內(nèi)容請(qǐng)搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！
相關(guān)文章
Go語言的變量、函數(shù)、Socks5代理服務(wù)器示例詳解
這篇文章主要介紹了Go語言的變量、函數(shù)、Socks5代理服務(wù)器的相關(guān)資料,需要的朋友可以參考下2017-09-09
深入理解Golang中的Protocol Buffers及其應(yīng)用
本篇文章將深入探討 Go 語言中使用 Protobuf 的基礎(chǔ)知識(shí)、常見應(yīng)用以及最佳實(shí)踐,希望能幫大家了解如何在項(xiàng)目中高效利用 Protobuf2024-11-11
習(xí)慣與函數(shù)式編程語言的開發(fā)者，會(huì)認(rèn)為for循環(huán)和if判斷語句是冗長(zhǎng)的代碼，通過使用map和filter處理集合元素讓代碼更可讀。本文介紹Go閉包實(shí)現(xiàn)集合轉(zhuǎn)換和過濾功能2023-01-01
正則表達(dá)式是一種強(qiáng)大的模式匹配工具，能夠在文本中進(jìn)行靈活的搜索和替換操作，本文將介紹?Golang?中的正則表達(dá)式語法，包括常用的匹配符號(hào)、模式修飾符以及示例應(yīng)用，希望對(duì)大家有所幫助2023-05-05
golang將切片或數(shù)組根據(jù)某個(gè)字段進(jìn)行分組操作
這篇文章主要介紹了golang將切片或數(shù)組根據(jù)某個(gè)字段進(jìn)行分組操作，具有很好的參考價(jià)值，希望對(duì)大家有所幫助。一起跟隨小編過來看看吧2020-12-12
Go并發(fā)控制WaitGroup的使用場(chǎng)景分析
WaitGroup，可理解為Wait-Goroutine-Group，即等待一組goroutine結(jié)束，本文通過具體場(chǎng)景結(jié)合實(shí)際例子給大家介紹使用WaitGroup控制的實(shí)現(xiàn)方法，感興趣的朋友跟隨小編一起看看吧2021-07-07
這篇文章介紹了Go語言中Goroutine的設(shè)置方式，文中通過示例代碼介紹的非常詳細(xì)。對(duì)大家的學(xué)習(xí)或工作具有一定的參考借鑒價(jià)值，需要的朋友可以參考下2022-07-07
在Go的http包中,每個(gè)請(qǐng)求由獨(dú)立的goroutine處理,這些goroutine可能需要訪問請(qǐng)求特定的數(shù)據(jù)或啟動(dòng)其他服務(wù),Context在Go語言中提供了一種方式來傳遞請(qǐng)求域的數(shù)據(jù)、取消信號(hào)和截止時(shí)間,本文介紹Go Context庫 使用基本示例,感興趣的朋友跟隨小編一起看看吧2024-09-09
Golang?實(shí)現(xiàn)Redis?協(xié)議解析器的解決方案
這篇文章主要介紹了Golang???實(shí)現(xiàn)?Redis?協(xié)議解析器,本文將分別介紹Redis 通信協(xié)議 以及 協(xié)議解析器 的實(shí)現(xiàn)，若您對(duì)協(xié)議有所了解可以直接閱讀協(xié)議解析器部分，需要的朋友可以參考下2022-10-10
這篇文章主要介紹了Golang 高并發(fā)問題的解決方案，具有很好的參考價(jià)值，希望對(duì)大家有所幫助。一起跟隨小編過來看看吧2021-05-05