1. 什么是反射
反射是程式在運行期間獲取變數的型別和值、或者執行變數的方法的能力，
Golang反射包中有兩對非常重要的函式和型別，兩個函式分別是：
reflect.TypeOf 能獲取型別資訊reflect.Type；
reflect.ValueOf 能獲取資料的運行時表示reflect.Value；
3. reflect.Type
Golang是一門靜態型別的語言，反射是建立在型別之上的，
通過reflect.TypeOf() 函式可以獲得任意值的型別資訊，
3.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
)
3.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
3.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}
4. 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
4.2 結構體的成員的值
和3.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]
4.3 遍歷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
4.4 遍歷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
5. 反射的三大定律
反射的兩個基礎函式定義，
- 獲取型別
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)資訊，
5.1 從interface到反射物件
interface{}承載變數的(value, concrete type)資訊，通過反射暴露方法來訪問interface{}的值和型別，
可以簡單理解為interface{}的值和資訊傳遞到reflect.Type和 reflect.Value，方便獲取，
5.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
5.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后續章節再分享通過修改各種型別的值的實操，
5. 參考檔案
laws-of-reflection
interface
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/539108.html
標籤：其他