Golang反射獲取變量類型和值的方法詳解
1. 什麼是反射
反射是程序在運行期間獲取變量的類型和值、或者執行變量的方法的能力。
Golang反射包中有兩對非常重要的函數和類型,兩個函數分別是:
reflect.TypeOf能獲取類型信息reflect.Type;
reflect.ValueOf 能獲取數據的運行時表示reflect.Value;
2. reflect.Type
Golang是一門靜態類型的語言,反射是建立在類型之上的。
通過reflect.TypeOf()函數可以獲得任意值的類型信息。
2.1 類型Type和種類Kind
諸如int32, slice, map以及通過type關鍵詞自定義的類型。
種類Kind可以理解為類型的具體分類。如int32、type MyInt32 int32是兩種不同類型,但都屬於int32這個種類。
使用 reflect.TypeOf()獲取變量類型以及種類。
func main() { type MyInt32 int32 a := MyInt32(1) b := int32(1) fmt.Printf("reflect.TypeOf(a):%v Kind:%v\n", reflect.TypeOf(a), reflect.TypeOf(a).Kind()) fmt.Printf("reflect.TypeOf(b):%v Kind:%v\n", reflect.TypeOf(b), reflect.TypeOf(b).Kind()) }
代碼輸出如下,由此可以看出int32、type MyInt32 int32是兩種不同類型,但都屬於int32這個種類。
$ go run main.go
reflect.TypeOf(a):main.MyInt32 Kind:int32
reflect.TypeOf(b):int32 Kind:int32
種類定義點擊查看
// 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()函數獲取。
func main() { type myStruct struct { } a := &myStruct{} typeA := reflect.TypeOf(a) fmt.Printf("TypeOf(a):%v Kind:%v\n", typeA, typeA.Kind()) fmt.Printf("TypeOf(a).Elem():%v Elem().Kind:%v\n", typeA.Elem(), typeA.Elem().Kind()) s := []int64{} typeS := reflect.TypeOf(s) fmt.Printf("TypeOf(s):%v Kind:%v\n", typeS, typeS.Kind()) fmt.Printf("TypeOf(s).Elem():%v Elem().Kind:%v\n", typeS.Elem(), typeS.Elem().Kind()) }
代碼輸出如下,由此可以看出,通過reflect.Elem()函數可以獲取引用指向數據的類型。
$ go run main.go
TypeOf(a):*main.myStruct Kind:ptr
TypeOf(a).Elem():main.myStruct Elem().Kind:struct
TypeOf(s):[]int64 Kind:slice
TypeOf(s).Elem():int64 Elem().Kind:int64
2.3 結構體成員類型
通過NumField獲取成員數量,Field通過下標訪問成員的類型信息StructField,包括成員名稱、類型、Tag信息等。
func main() { 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 } s := myStruct{} typeS := reflect.TypeOf(s) // 成員數量 fmt.Printf("NumField:%v \n", typeS.NumField()) // 每個成員的信息 包括名稱、類型、Tag for i := 0; i < typeS.NumField(); i++ { // 通過下標訪問成員 fmt.Printf("Field(%v):%+v\n", i, typeS.Field(i)) } // 通過名稱訪問成員 field, ok := typeS.FieldByName("Num") fmt.Printf("FieldByName(\"Num\") ok:%v field:%+v\n", ok, field) // 獲取tag值 fmt.Printf("json tag val:%+v\n", field.Tag.Get("json")) // 獲取嵌套結構體的字段 fmt.Printf("Cnt field:%+v\n", typeS.FieldByIndex([]int{2, 0})) }
代碼輸出如下,
$ go run main.go
NumField:3
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}
FieldByName("Num") ok:true field:{Name:Num PkgPath: Type:int Tag:json:"num_json" orm:"column:num_orm" Offset:0 Index:[0] Anonymous:false}
json tag val:num_json
Cnt field:{Name:Cnt PkgPath: Type:[]int64 Tag: Offset:0 Index:[0] Anonymous:false}
3. reflect.Value
通過reflect.ValueOf獲取變量值、值類型,種類為Array, Chan, Map, Slice, 或String可通過Len()獲取長度
func main() { b := int32(1) valueB := reflect.ValueOf(b) fmt.Printf("reflect.TypeOf(b):%v Kind:%v\n", valueB, valueB.Kind()) s := "abcdefg" valueS := reflect.ValueOf(s) fmt.Printf("reflect.TypeOf(s):%v Kind:%v Len:%v\n", valueS, valueS.Kind(), valueS.Len()) }
代碼輸出如下,
$ go run main.go
reflect.TypeOf(b):1 Kind:int32
reflect.TypeOf(s):abcdefg Kind:string Len:7
3.1 結構體的成員的值
和2.3 結構體成員類型獲取結構體成員類型類似,reflect提供瞭NumField獲取成員數量,Field通過下標訪問成員的值。
func main() { 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 } s := myStruct{ Num: 100, Desc: "desc", Child: secStruct{[]int64{1, 2, 3}}, } valueS := reflect.ValueOf(s) // 成員數量 fmt.Printf("NumField:%v \n", valueS.NumField()) // 每個成員的值 for i := 0; i < valueS.NumField(); i++ { // 通過下標訪問成員 fmt.Printf("value(%v):%+v\n", i, valueS.Field(i)) } // 通過名稱訪問成員 value := valueS.FieldByName("Num") fmt.Printf("FieldByName(\"Num\") value:%v\n", value) // 獲取嵌套結構體的字段 fmt.Printf("Cnt field:%+v\n", valueS.FieldByIndex([]int{2, 0})) }
代碼輸出如下
$ go run main.go
NumField:3
value(0):100
value(1):desc
value(2):{Cnt:[1 2 3]}
FieldByName("Num") value:100
Cnt field:[1 2 3]
3.2 遍歷array、slice
通過func (v Value) Index(i int) Value可以通過下標來訪問Array, Slice,或者 String各個元素的值。
func main() { s := []int64{1, 2, 3, 4, 5, 6} valueS := reflect.ValueOf(s) fmt.Printf("ValueOf(s):%v Kind:%v Len:%v\n", valueS, valueS.Kind(), valueS.Len()) for i := 0; i < valueS.Len(); i++ { fmt.Printf("valueS.Index(%v):%v\n", i, valueS.Index(i)) } }
代碼輸出如下
$ go run main.go
ValueOf(s):[1 2 3 4 5 6] Kind:slice Len:6
valueS.Index(0):1
valueS.Index(1):2
valueS.Index(2):3
valueS.Index(3):4
valueS.Index(4):5
valueS.Index(5):6
3.3 遍歷map
reflect有兩種方法遍歷map
通過迭代器MapIter遍歷map
先獲取map的所有key,再通過key獲取對應的value
func main() { m := map[int]string{ 1: "1", 2: "2", 3: "3", } valueM := reflect.ValueOf(m) // 迭代器訪問 iter := valueM.MapRange() for iter.Next() { fmt.Printf("key:%v val:%v\n", iter.Key(), iter.Value()) } fmt.Println("------") // 通過key訪問 keys := valueM.MapKeys() for i := 0; i < len(keys); i++ { fmt.Printf("key:%v val:%v\n", keys[i], valueM.MapIndex(keys[i])) } }
代碼輸出如下,
$ go run main.go
key:1 val:1
key:2 val:2
key:3 val:3
——
key:3 val:3
key:1 val:1
key:2 val:2
4. 反射的三大定律
反射的兩個基礎函數定義,
- 獲取類型func TypeOf(i any) Type
- 獲取值func ValueOf(i any) Value
其中,any是interface{}的別名。
interface{}是不包含任何方法簽名的空接口,任何類型都實現瞭空接口。
A value of interface type can hold any value that implements those methods.
因此,interface{}可以承載任何變量的 (value, concrete type)信息。
4.1 從interface到反射對象
interface{}承載變量的(value, concrete type)信息,通過反射暴露方法來訪問interface{}的值和類型。
可以簡單理解為interface{}的值和信息傳遞到reflect.Type和 reflect.Value,方便獲取。
4.2 從反射對象到interface
可以通過函數func (v Value) Interface() (i any)將反射對象轉換為interface{},
是func ValueOf(i any) Value的反向操作。
func main() { a := int32(10) valueA := reflect.ValueOf(a) fmt.Printf("ValueOf(a):%v\n", valueA) fmt.Printf("Interface():%v\n", valueA.Interface()) ai, ok := valueA.Interface().(int32) fmt.Printf("ok:%v val:%v\n", ok, ai) }
代碼輸出如下
$ go run main.go
ValueOf(a):10
Interface():10
ok:true val:10
4.3 通過反射修改對象,該對象值必須是可修改的
reflect提供func (v Value) CanSet() bool判斷對象值是否修改,通過func (v Value) Set(x Value)修改對象值
func main() { a := int32(10) valueA := reflect.ValueOf(a) fmt.Printf("valueA :%v\n", valueA.CanSet()) b := int32(100) valuePtrB := reflect.ValueOf(&b) fmt.Printf("valuePtrB:%v Elem:%v\n", valuePtrB.CanSet(), valuePtrB.Elem().CanSet()) valuePtrB.Elem().Set(reflect.ValueOf(int32(200))) fmt.Printf("b:%v Elem:%v\n", b, valuePtrB.Elem()) }
代碼輸出如下
$ go run main.go
valueA :false
valuePtrB:false Elem:true
b:200 Elem:200
到此這篇關於Golang反射獲取變量類型和值的方法詳解的文章就介紹到這瞭,更多相關Golang反射獲取變量類型 值內容請搜索WalkonNet以前的文章或繼續瀏覽下面的相關文章希望大傢以後多多支持WalkonNet!