反射
反射介绍
Go是静态类型的语言。每个变量都有一种静态类型。换言之，它们都有一种已知的类型， 并且在编译时就确定下来了。比如 int 、 float32 、 *MyType 或 []byte 等等。
如果我们定义了
type MyInt int var i int // i 的类型为 int var j MyInt // j 的类型为 MyInt // 尽管变量 i 和 j 拥有相同的底层类型， 但它们的静态类型仍然不同，因此它们在未经转换前是无法相互赋值的。
要知道，Go语言中的变量是分为两部分的:
- 类型信息：预先定义好的元信息。
- 值信息：程序运行过程中可动态变化的。
反射是指在程序运行期对程序本身进行访问和修改的能力。程序在编译时，变量被转换为内存地址，变量名不会被编译器写入到可执行部分。在运行程序时，程序无法获取自身的信息。
支持反射的语言可以在程序编译期将变量的反射信息，如字段名称、类型信息、结构体信息等整合到可执行文件中，并给程序提供接口访问反射信息，这样就可以在程序运行期获取类型的反射信息，并且有能力修改它们。
Go程序在运行期使用reflect包访问程序的反射信息。
在上一篇博客中我们介绍了空接口。 空接口可以存储任意类型的变量，那我们如何知道这个空接口保存的数据是什么呢？ 反射就是在运行时动态的获取一个变量的类型信息和值信息。
反射用法
初识reflect包
首先，我们要知道reflect是一个go语言内置的标准库，因此可以直接通过import "reflect"导入使用，其次，我们还要了解 reflect 包中的两种类型： Type 和 Value，这两种类型可用来访问接口变量的内容。还有两个简单的函数，叫做 reflect.TypeOf 和 reflect.ValueOf ， 它们用来从接口值中分别获取 reflect.Type 和 reflect.Value 。
Typeof
我们已经知道了,go语言的任何变量都是由两部分组成的，类型和值。这里的类型指的是一个静态类型。我们可以使用Typeof方法获取。
package main import ( "fmt" "reflect" ) func main() { var x float64 = 3.4 fmt.Println("type:", reflect.TypeOf(x)) //type: float64 }
上面的程序看起来只是向 reflect.TypeOf 传递了一个 float64 类型的变量 x ，而不是一个接口值。实际上reflect.TypeOf 的签名包含了一个空接口：
// TypeOf 返回 interface{} 中的值的反射类型 Type。 func TypeOf(i interface{}) Type ''' 当我们调用 reflect.TypeOf(x) 时： x 首先会被存储在一个空接口中， 然后它会作为实参被传入； reflect.TypeOf 通过解包该空接口来还原其类型信息，reflect.ValueOf 函数也会还原它的值。 '''
Kind 基础类型
在go语言中我们可以使用type关键字构造很多自定义类型，这称为静态类型；
事实上，我们使用TypeOf获取到的是一个封装好的静态类型对象，而在go语言底层所有的自定义类型都有对应的基础类型定义，如果我们要查看这些对象的基础类型可以调用Kind方法。
package main import ( "fmt" "reflect" ) type student struct { name string age int } func main(){ s := student{"Eva",18} p := &student{"Eva",18} stype := reflect.TypeOf(s) ptype := reflect.TypeOf(p) fmt.Println(s,stype,stype.Kind()) //{Eva 18} main.student struct fmt.Println(p,ptype,ptype.Kind()) //&{Eva 18} *main.student ptr }
我们可以看下，对于student类型的指针和对象，typeof可以判断出它的student类型，而使用Kind获取的数据就是struct结构体类型和ptr指针类型，这些都是go语言的底层类型。
type Kind uint const ( Invalid Kind = iota // 非法类型 Bool // 布尔型 Int // 有符号整型 Int8 // 有符号8位整型 Int16 // 有符号16位整型 Int32 // 有符号32位整型 Int64 // 有符号64位整型 Uint // 无符号整型 Uint8 // 无符号8位整型 Uint16 // 无符号16位整型 Uint32 // 无符号32位整型 Uint64 // 无符号64位整型 Uintptr // 指针 Float32 // 单精度浮点数 Float64 // 双精度浮点数 Complex64 // 64位复数类型 Complex128 // 128位复数类型 Array // 数组 Chan // 通道 Func // 函数 Interface // 接口 Map // 映射 Ptr // 指针 Slice // 切片 String // 字符串 Struct // 结构体 UnsafePointer // 底层指针 )
Valueof
当然， reflect.ValueOf 函数也会还原它的值：
func main() { var x float64 = 3.4 fmt.Println("type:", reflect.TypeOf(x)) v := reflect.ValueOf(x) fmt.Println("value:", v,reflect.TypeOf(v)) // value: 3.4 reflect.Value inter_v := reflect.ValueOf(x).Interface() fmt.Println("value:", inter_v,reflect.TypeOf(inter_v)) // value: 3.4 float64
通过reflect.ValueOf()返回的是reflect.Value类型，其中包含了原始值的值信息。我们可以使用 .Interface()方法还原其接口值；在效果上，该方法会将类型与值的信息打包成接口表示，并返回其结果。也可以使用reflect.Value与原始值之间互相转换。
reflect.Value类型提供的获取原始值的方法如下：
| 方法 | 说明 |
|---|---|
| Interface() interface {} | 将值以 interface{} 类型返回，可以通过类型断言转换为指定类型 |
| Int() int64 | 将值以 int 类型返回，所有有符号整型均可以此方式返回 |
| Uint() uint64 | 将值以 uint 类型返回，所有无符号整型均可以此方式返回 |
| Float() float64 | 将值以双精度（float64）类型返回，所有浮点数（float32、float64）均可以此方式返回 |
| Bool() bool | 将值以 bool 类型返回 |
| Bytes() []bytes | 将值以字节数组 []bytes 类型返回 |
| String() string | 将值以字符串类型返回 |
为了让 API 保持简单， Value 的 getter 和 setter 方法会在能够保存其值的最大类型上进行操作：例如 int64 就能用于所有的带符号整数。也就是说， Value 的 Int 方法会返回 int64 类型的值，而 SetInt 会接收 int64 类型的值；因此该值可能需要转换为它所涉及到的实际类型：
package main import ( "fmt" "reflect" ) func reflectValue(x interface{}) { v := reflect.ValueOf(x) k := v.Kind() switch k { case reflect.Int32: // v.Int()从反射中获取整型的原始值，然后通过int64()强制类型转换 fmt.Printf("type is int32, value is %d\n", int32(v.Int())) case reflect.Int64: // v.Int()从反射中获取整型的原始值，然后通过int64()强制类型转换 fmt.Printf("type is int64, value is %d\n", int64(v.Int())) case reflect.Float32: // v.Float()从反射中获取浮点型的原始值，然后通过float32()强制类型转换 fmt.Printf("type is float32, value is %f\n", float32(v.Float())) case reflect.Float64: // v.Float()从反射中获取浮点型的原始值，然后通过float64()强制类型转换 fmt.Printf("type is float64, value is %f\n", float64(v.Float())) } } func main() { var a float32 = 3.14 var b int32 = 100 c := reflect.ValueOf(a) fmt.Printf("type c :%T , %T , %s\n", c,c.Float(),c.Kind()) // type d :reflect.Value , int64 ,int32 d := reflect.ValueOf(b) fmt.Printf("type d :%T , %T ,%s\n", d,d.Int(),d.Kind()) // type c :reflect.Value , float64 , float32 reflectValue(a) // type is float32, value is 3.140000 reflectValue(b) // type is int32, value is 100 }
反射修改值
func Info(o interface{}) { v := reflect.ValueOf(o) v.Elem().SetInt(100) fmt.Println(v.Elem()) // 100 } func main() { u := 50 Info(&u) fmt.Println(u) // 100 }
空接口、结构体与反射
在之前的介绍中，我们已经知道空接口能够忽略类型，把任意类型的对象作为参数接收到函数中来。
package main import ( "fmt" ) type User struct { // 用户结构体 Id int Name string Age int } type Goods struct { // 物品结构体 Id int Name string } func (u User) pay() { fmt.Printf("%s pay for the bill\n",u.Name) } func show_info(i interface{}){ fmt.Println(i) // {1 Eva 18} 或者 {1 apple} //fmt.Println(i.Name) // 编译报错 } func main(){ u := User{1,"Eva",18} g := Goods{1,"apple"} show_info(u)
上述代码中，我们用空接口来接收结构体对象，虽然可以接收成功，但是却无法获取到它的值。这样很容易理解，当i是一个接口的时候，无法获知即将传递过来的对象是否含有Name或其他属性，因此直接获取属性值的操作是无法在编译阶段通过的。这时，我们就需要用到反射，之前介绍过，反射可以在程序运行期对程序本身进行访问和修改，如果程序已经允许到该位置，那么该对象中只要存在对应的属性，就可以用反射获取。
与结构体相关的方法
任意值通过reflect.TypeOf()获得反射对象信息后，如果它的类型是结构体，可以通过反射值对象（reflect.Type）的NumField()和Field()方法获得结构体成员的详细信息。
reflect.Type中与获取结构体成员相关的的方法如下表所示。
| 方法 | 说明 |
|---|---|
| Field(i int) StructField | 根据索引，返回索引对应的结构体字段的信息。 |
| NumField() int | 返回结构体成员字段数量。 |
| FieldByName(name string) (StructField, bool) | 根据给定字符串返回字符串对应的结构体字段的信息。 |
| FieldByIndex(index []int) StructField | 多层成员访问时，根据 []int 提供的每个结构体的字段索引，返回字段的信息。 |
| FieldByNameFunc(match func(string) bool) (StructField,bool) | 根据传入的匹配函数匹配需要的字段。 |
| NumMethod() int | 返回该类型的方法集中方法的数目 |
| Method(int) Method | 返回该类型方法集中的第i个方法 |
| MethodByName(string)(Method, bool) | 根据方法名返回该类型方法集中的方法 |
StructField类型 StructField类型用来描述结构体中的一个字段的信息。 StructField的定义如下： type StructField struct { // Name是字段的名字。PkgPath是非导出字段的包路径，对导出字段该字段为""。 // 参见http://golang.org/ref/spec#Uniqueness_of_identifiers Name string PkgPath string Type Type // 字段的类型 Tag StructTag // 字段的标签 Offset uintptr // 字段在结构体中的字节偏移量 Index []int // 用于Type.FieldByIndex时的索引切片 Anonymous bool // 是否匿名字段 }
反射类型和字段
type Cat struct{ Name string Eye_color string } type Dog struct{ Name string } func eat(e interface{}){ fmt.Printf("%s在吃东西\n",e) // {阿花 blue}在吃东西 //fmt.Printf("%s在吃东西",e.name) 编译报错 t := reflect.TypeOf(e) // 查看type k := t.Kind() // 查看kind n := t.Name() // 查看name fmt.Println("k,n :",k,n) // k = struct n = cat fmt.Printf("t : %s , t.NumField : %d\n",t,t.NumField()) // t : main.Cat , t.NumField : 2 v := reflect.ValueOf(e) fmt.Println("value : ",v) // value : {阿花 blue} fmt.Println("t.Field :",t.Field(0)) // t.Field : {Name string 0 [0] false} fmt.Println("v.Field :",v.Field(0)) // v.Field : 阿花 fmt.Println("v.FieldByName :",v.FieldByName("Name")) //v.FieldByName : 阿花 fmt.Println(v.Field(0).Interface()) //阿花 } func main(){ var num int fmt.Print("请输入序号选择喂猫或狗(1.猫;2.狗) :") fmt.Scanf("%d",&num) //输入1 if num == 1{ e := Cat{"阿花","blue"} eat(e) } else if num == 2{ e := Dog{"alex"} eat(e) } }
查询匿名字段信息
package main import ( "fmt" "reflect" ) type User struct { Id int Name string int } func (u User) Hello() { fmt.Println("Hello User!") } func Info(o interface{}) { t := reflect.TypeOf(o) //reflect.StructField{Name:"int", PkgPath:"main", Type:(*reflect.rtype)(0x10ac760), Tag:"", Offset:0x18, Index:[]int{2}, Anonymous:true} fmt.Printf("%#v\n",t.Field(2)) // Anonymous:true 表示当前字段是一个匿名字段 } func main() { u := User{1, "Mr.Sun", 18} Info(u) }
反射和调用方法
package main import ( "fmt" "reflect" ) type User struct { Id int Name string Age int } func (u User) Hello() { fmt.Println("Hello User!") } func Info(o interface{}) { t := reflect.TypeOf(o) m := t.Method(0) fmt.Printf("%s|%v\n",m.Name,m.Type) v := reflect.ValueOf(o) // 通过反射调用方法传递的参数必须是 []reflect.Value 类型 var args = []reflect.Value{} v.Method(0).Call(args) // 通过索引调用 v.MethodByName("Hello").Call(args) // 通过名字调用 } func main() { u := User{1, "Mr.Sun", 18} Info(u) }
修改结构体
package main import ( "fmt" "reflect" ) type User struct { Id int Name string Age int } func Info(o interface{}) { v := reflect.ValueOf(o) id := v.Elem().FieldByName("Id") id.SetInt(2) } func main() { u := User{1, "Mr.Sun", 18} Info(&u) fmt.Println(u) }
获取tag
package main import ( "fmt" "reflect" ) type User struct { Id int `tag:"id"` Name string Age int } func Info(o interface{}) { t := reflect.TypeOf(o) field := t.Field(0) fmt.Println("--> ",field.Tag.Get("tag")) } func main() { u := User{1, "Mr.Sun", 18} Info(u) }
反射与异常
package main import ( "fmt" "reflect" ) type User struct { Id int Name string int } func (u User) Hello() { fmt.Println("Hello User!") } func Info(o interface{}) { t := reflect.TypeOf(o) v := reflect.ValueOf(o) fmt.Println(t.MethodByName("He")) //{ <nil> <invalid Value> 0} false fmt.Println(v.MethodByName("He")) //<invalid reflect.Value> fmt.Println(t.FieldByName("Nam")) //{ <nil> <invalid Value> 0} false fmt.Println(v.FieldByName("Nam")) //<invalid reflect.Value> //fmt.Println(t.Field(3)) //panic: reflect: Field index out of bounds //fmt.Println(v.Field(3)) //panic: reflect: Field index out of bounds //fmt.Println(t.Method(1)) //panic: reflect: Method index out of range //fmt.Println(v.Method(1)) //panic: reflect: Method index out of range } func main() { u := User{1, "Mr.Sun", 18} Info(u) }
isNil()和isValid()
isNil() : IsNil()报告v持有的值是否为nil。v持有的值的分类必须是通道、函数、接口、映射、指针、切片之一；否则IsNil函数会导致panic。
func (v Value) IsNil() bool
isValid() : IsValid()返回v是否持有一个值。如果v是Value零值会返回假，此时v除了IsValid、String、Kind之外的方法都会导致panic。
func (v Value) IsValid() bool
示例：
package main import ( "fmt" "reflect" ) type User struct { Id int Name string Age *int } func (u User) Hello() { fmt.Println("Hello User!") } func Info(o interface{}) { v := reflect.ValueOf(o) fmt.Println(v.FieldByName("Age").IsNil()) //True fmt.Println(v.MethodByName("He").IsValid()) //false fmt.Println(v.MethodByName("Id").IsValid()) //false } func main() { u2 := User{ Name:"Mr.Sun"} Info(u2) }
修改、指针和反射
通过反射设置变量的值，想要在函数中通过反射修改变量的值，需要注意函数参数传递的是值拷贝，必须传递变量地址才能修改变量值。而反射中使用专有的Elem()方法来获取指针对应的值。
package main import ( "fmt" "reflect" ) func reflectSetValue1(x interface{}) { v := reflect.ValueOf(x) if v.Kind() == reflect.Int64 { v.SetInt(200) //修改的是副本，reflect包会引发panic } } func reflectSetValue2(x interface{}) { v := reflect.ValueOf(x) // 反射中使用 Elem()方法获取指针对应的值 if v.Elem().Kind() == reflect.Int64 { v.Elem().SetInt(200) } } func main() { var a int64 = 100 // reflectSetValue1(a) //panic: reflect: reflect.Value.SetInt using unaddressable value reflectSetValue2(&a) fmt.Println(a) }
反射是把双刃剑
反射是一个强大并富有表现力的工具，能让我们写出更灵活的代码。但是反射不应该被滥用，原因有以下三个。
- 基于反射的代码是极其脆弱的，反射中的类型错误会在真正运行的时候才会引发panic，那很可能是在代码写完的很长时间之后。
- 大量使用反射的代码通常难以理解。
- 反射的性能低下，基于反射实现的代码通常比正常代码运行速度慢一到两个数量级。
反射练习
- 编写代码利用反射实现一个ini文件的解析器程序。
浙公网安备 33010602011771号