变量的内在机制

Go语言中的变量是分为两部分的：

  • 类型信息：预先定义好的元信息。
  • 值信息：程序运行过程中可动态变化的。

反射介绍

反射是指载程序运行期间对程序本身进行访问和修改的能力。程序在编译时，变量被转换为内存地址，变量名不会被编译器写入到可执行部分。在程序运行时，程序无法获取自身信息。

支持反射的语言可以在程序编译期将变量的反射信息，如字段，类型信息，结构体信息等整合到可执行文件中，并给程序提供接口访问反射信息，并且有能力修改他们。

Go语言使用reflect包方访问程序的反射信息。

reflect包

在Go语言反射机制中，任何接口值都是由一个具体类型和具体类型的值两部分组成的。在Go语言的反射的相关功能是由内置的reflect包提供，任意接口值在反射中都可以理解为由reflect.Type和reflect.Value两部分组成，并且reflect包提供了reflect.TypeOf()和reflect.ValueOf()两个函数来获取任意对象的Value和Type。

TypeOf

在Go语言中，使用reflect.TypeOf()函数可以获取任意值的类型对象(reflect.Type)，程序通过类型对象可以访问任意值的类型信息.

type name和type kind

在反射中关于类型还划分为两种: 类型(type)和种类(kind).因为在Go语言中我们可以使用type关键字构建很多自定义类型,而种类(kind)就是指底层的类型,但在反射中,当需要区分指针,结构体等大品钟的类型时,就会用到种类(kind).

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
type myInt int64

type person struct {
   name string
   age int
}

type book struct {
   title string
}

var d = person{
   name: "子淳平",
   age: 66,
}

var e = book{"《跟小王子学Go语言》"}

func reflectType(x interface{}){
   typeOf := reflect.TypeOf(x)
   //类型
   fmt.Printf("type：%v\n", typeOf.Name())
   //种类
   fmt.Printf("kind：%v\n", typeOf.Kind())
   fmt.Println("-----------------------")
}

func main() {
   var a *float32 //指针
   var b myInt //自定义类型
   var c rune //类型别名
   reflectType(a) //type: kind:prt
   reflectType(b) //type：myInt kind：int64
   reflectType(c) //type：int32 kind：int32
   reflectType(d)//type：person kind：struct
   reflectType(e)//type：book kind：struct
}

Go语言的反射中,像数组、切片、map、指针等类型的变量，他们的.Name()都是返回空.

在reflect包中定义的Kind类型如下：

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
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()返回的值是reflect.Value类型，其中包含了原始值的信息。

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 将值以字符串类型返回

通过反射获取值

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
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\n", 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 float64 = 100
   reflectValue(a) //type is float32, value is 3.140000
   reflectValue(b)    //type is float64, value is 100.000000
   //将int类型的原始值类型转换为reflect.Value类型
   c := reflect.ValueOf(10)
   fmt.Printf("type c: %T\n", c) //type c: reflect.Value
}

通过反射设置变量值

想要在函数中通过反射修改变更量的值，需要注意函数参数传递是值拷贝，必须传递变量地址值才能修改变量值。而反射中使用专有的Elem()方法来获取指针对应的值，并且通过Elem().Setxxx()设置值。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
//传递值，修改的是副本，reflect包会引起panic
func reflectSetValue1(x interface{}){
   valueOf := reflect.ValueOf(x)
   if valueOf.Kind() == reflect.Int64{
      valueOf.SetInt(200) //修改的是副本的值，reflect包会引发panic
   }
}

func reflectSetValue2(x interface{}){
   valueOf := reflect.ValueOf(x)
   //反射中使用Elem()方法获取指针对应的值
   if valueOf.Elem().Kind() == reflect.Int64 {
      valueOf.Elem().SetInt(200)
   }
}

func main() {
   var a int64 = 100
   //reflectSetValue1(a) // panic: reflect: reflect.flag.mustBeAssignable using unaddressable value
   reflectSetValue2(&a)
   fmt.Println(a)
}

IsNil()和IsValid()

IsNil()
1
func (v Value) IsNil() bool

IsNil()报告v持有的值是否为nil。v持有的值分类必须是通道，函数，接口，映射，指针，切片之一；否则IsNil()函数会导致panic。

IsValid()
1
func (v Value) IsValid() bool

IsValid()返回v是否持有一个值。如果v是Value零值会返回假，此时v除了I是Valid，String，Kind之外的方法都会panic。

IsNil()常用来判断指针是否为空；IsValid()常用于判断返回值是否有效。

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
39
40
41
func reflectIsNil(x interface{}){
   valueOf := reflect.ValueOf(x)
   isNil := valueOf.IsNil()
   fmt.Printf("isNil : %v\n", isNil)
}

func reflectIsValid(x interface{}){
   valueOf := reflect.ValueOf(x)
   valid := valueOf.IsValid()
   fmt.Printf("IsValid : %v\n", valid)
}

func main() {
   var a []int
   reflectIsNil(a) //isNil : true
   reflectIsValid(a) //isValid : true
   a = make([]int, 16)
   a[0] = 1
   reflectIsNil(a) //isNil : false
   reflectIsValid(a) //isValid : true

   reflectIsNilAndIsValid()
}

func reflectIsNilAndIsValid(){
   // *int空指针
   var a *int
   fmt.Println("var a *int IsNil:", reflect.ValueOf(a).IsNil()) //var a *int IsNil: true
   // nil
   fmt.Println("nil IsValid:", reflect.ValueOf(nil).IsValid()) //nil IsValid: false
   //实例化一个结构体
   b := struct {}{}
   // 尝试从结构体中查找“abc”字段
   fmt.Println("不存在的结构体成员：", reflect.ValueOf(b).FieldByName("abc").IsValid()) //不存在的结构体成员：false
   // 尝试从结构体中查找“abc”方法
   fmt.Println("不存在的结构体方法：", reflect.ValueOf(b).MethodByName("abc").IsValid())  //不存在的结构体方法：false
   // map
   c := map[string]int{}
   //尝试从map中查找不存在的健
   fmt.Println("map中不存在的键：", reflect.ValueOf(c).MapIndex(reflect.ValueOf("张三")).IsValid()) //map中不存在的键: false
}

结构体反射

与结构体相关的方法

任意值通过reflect.TypeOf()获取反射对象信息后，如果他的类型是结构体，可以通过反射值对象reflect.ValueOf()的NumField()和Field()方法获得结构体成员的详细信息。

方法 说明
Field(int) StrucField 根据，返回索引对应的结构体字段的信息
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, bol) 根据方法名返回该类型方法集中的方法。

StructField类型

1
2
3
4
5
6
7
8
9
10
11
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      // 是否匿名字段
}

反射获取属性

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
type Person struct {
   Name string `json:"name"`
   Age int `json:"age"`
   Tel string `json:"tel"`
   Hobby []string `json:"hobby"`
}

func NewPerson(name string, age int, tel string, hobby []string) *Person {
   return &Person{Name: name, Age: age, Tel: tel, Hobby: hobby}
}

func (p Person)eat(food string){
   fmt.Printf("吃：%s", food)
}

func (p Person)run(){
   fmt.Printf("跑！！！")
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
//遍历所有属性信息
func reflectField(x interface{}){
   typeOf := reflect.TypeOf(x)
   num := typeOf.Elem().NumField()
   for i := 0; i < num; i++{
      field := typeOf.Elem().Field(i)
      fmt.Println("field:" , field)
   }
}

func main() {
   person := NewPerson("张三", 18, "13812345678", []string{"听歌", "睡觉"})
   reflectField(person)
   typeOf := reflect.TypeOf(person)
   fmt.Println(typeOf.Name(), typeOf.Kind())
}

反射调用方法

1
2
3
4
5
6
7
8
9
10
11
12
13
func reflectMethod(x interface{}) {
   typeOf := reflect.TypeOf(x)
   valueOf := reflect.ValueOf(x)
   num := valueOf.NumMethod()
   for i := 0; i < num; i++ {
      methodType := valueOf.Method(i).Type()
      fmt.Printf("method name is : %s\n", typeOf.Method(i).Name)
      fmt.Printf("method:%s\n", methodType)
   }
   //通过反射调用方法传递的参数必须是[]reflect.Value类型
   args := []reflect.Value{reflect.ValueOf("鸡肉")}
   valueOf.MethodByName("Eat").Call(args)
}