go语言提供了一种机制，在编译时不知道类型的情况下，可更新变量，在运行时查看值，调用方法以及直接对他们的布局进行操作。这种机制称为反射(reflection)。
为什么使用反射
有时候我们需要写一个函数有能力统一处理各种值类型的函数，而这些类型可能无法共享同一个接口，也可能布局未知，也有可能这个类型在我们设计函数时还不存在。甚至这个类会同时存在上面三个问题。假设我们设计一个例子来判断，如下
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
package mainimport "fmt"type stringer interface { Stringer() string}func Sprint(x interface{}) { switch x := x.(type) { case stringer: fmt.Println(x, "is stringer") case string: fmt.Println(x, "is string") case int: fmt.Println("int") default: fmt.Println("其他类型") }}func main() { Sprint("fd")} |
这时你会发现，如果类型很多或者更多不确定的类型就会很麻烦。所以我们引入了reflect包。
reflect
反射功能由reflect包提供，它定义了两个重要的类型：Type和Value，并且TypeOf和ValueOf
- Type: 这是一个接口，真正使用该接口的实例是reflect.rtype，该实例持有动态类型的所有信息。并且提供下面方法
- kind(): 获取具体类型的底层类型。
- Elem(): 这个方法返回的是原始变量的元素的类型。
- Value: 这是一个struct,持有动态值的所有信息。
- Type(): Type方法返回接口变量的动态类型信息，也就是传入ValueOf方法的原始变量的类型。
- Kind(): 与Type的kind方法一样，返回的是原始类型。
- Interface():把一个reflect.Value对象还原回一个空接口类型的变量，可以通过类型断言：x, ok := v.Interface().(int)
- Elem(): 调用该方法的Value对象
type.kind() &type.name()
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
|
package mainimport ( "fmt" "reflect")type myInt int64func reflectType(x interface{}) { t := reflect.TypeOf(x) fmt.Printf("type:%v kind:%v
", t.Name(), t.Kind())}func main() { var a *float32 // 指针 var b myInt // 自定义类型 var c rune // 类型别名//代表int32 reflectType(a) // type: kind:ptr reflectType(b) // type:myInt kind:int64 reflectType(c) // type:int32 kind:int32 type person struct { name string age int } var d = person{ name: "wang", age: 18, } reflectType(d) // type:person kind:struct} |
TypeOf
TypeOf函数接收任何的interface{}参数，并且把接口中的动态类型以reflect.Type形式返回。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
package mainimport ( "fmt" "reflect")func reflectType(x interface{}) { v := reflect.TypeOf(x) fmt.Printf("type:%v
", v)}func main() { var a float32 = 3.14 reflectType(a) // type:float32 var b int64 = 100 reflectType(b) // type:int64} |
ValueOf
ValueOf函数可以接收任意的interface{}并将接口的动态值以reflect.Value的形式返回。与reflect.TypeOf类似，reflect.ValueOf的返回值也是具体值，不过reflect.Value也可以包含一个接口值。
对于不同类型，我们用reflect.Value的kind方法来区分不同类型。但类型的分类（kind）只有少数几种：
- 基础类型： Bool, String以及数字类型
- 聚合类型：Array, struct
- 引用类型：Chan, Func, Ptr, Slice, Map
- 接口类型：interface
- Invalid类型：表示没有任何值。reflect.Value的零值就属于Invalid类型。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
|
package mainimport ( "fmt" "reflect")func reflectValue(x interface{}) { v := reflect.ValueOf(x) k := v.Kind() switch k { case reflect.Int64: // v.Int()从反射中获取整型的原始值，然后通过int64()强制类型转换 fmt.Printf("type is int64, value is %d
", int64(v.Int())) case reflect.Float32: // v.Float()从反射中获取浮点型的原始值，然后通过float32()强制类型转换 fmt.Printf("type is float32, value is %f
", float32(v.Float())) case reflect.Float64: // v.Float()从反射中获取浮点型的原始值，然后通过float64()强制类型转换 fmt.Printf("type is float64, value is %f
", float64(v.Float())) }}func main() { var a float32 = 3.14 var b int64 = 100 reflectValue(a) // type is float32, value is 3.140000 reflectValue(b) // type is int64, value is 100 // 将int类型的原始值转换为reflect.Value类型 c := reflect.ValueOf(10) fmt.Printf("type c :%T
", c) // type c :reflect.Value} |
value.Elem设置值
上面知识获取了值及类型，如果想要修改，可以通过elem，但必须传递的是指针
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
package mainimport ( "fmt" "reflect")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 reflectSetValue2(&a) fmt.Println(a)} |
最后整理一下常用的类型判断，如
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
|
func Dis(path string, v reflect.Value) { switch v.Kind() { case reflect.Invalid: // 空 fmt.Printf("%s= Invalid
", path) case reflect.Slice, reflect.Array: for i := 0; i<v.Len(); i++{ Dis(fmt.Printf("%s[%d]", path, i), v.Index(i)) } case reflect.Struct: for i := 0; i< v.NumField(); i++{ feildPath := fmt.Sprintf("%s.%s",path, v.Type().Field(i).Name) Dis(feildPath, v.Field(i)) } case reflect.Map: for _, key :=range v.MapKeys(){ fmt.Printf("%s", v.MapIndex(key)) } case reflect.Ptr: if v.IsNil(){ fmt.Printf("%s= nil
", path) }else { Dis(fmt.Sprintf("*%s",path),v.Elem()) } case reflect.Interface: if v.IsNil(){ fmt.Printf("%s=nil
", path) }else { fmt.Printf("%s.type=%s
",path, v.Elem().Type()) } default: // 基础类型，chan, 函数 fmt.Printf("%s
",path) }} |