Go语言之反射（反射的简单使用，原理）_go语言反射原理

作者：IT小白 | 2024-02-29 06:24:05

踩

go语言反射原理

一、反射的基础

1.什么是反射

Go语言中，反射的机制就是在运行的时候，可以获取到其变量的类型和值，且可以对其类型和值进行检查，对其值进行修改。
即在不知道具体的类型的情况下，可以用反射机制来查看变量类型、更新变量的值。
Go中反射主要涉及到两个概念：Type和Value。对所有的接口进行反射时，都可以得到一个包含Type和Value的信息结构，Type是反射的这个变量本身的类型信息，Value是反射的这个变量本身的值信息。

2.反射的使用

(1) 获取到变量类型

方法：reflect.TypeOf(x)

作用：获取变量x的类型信息

package main

import (
	"fmt"
	"reflect"
)

func main(){
	x := 3.1415
	y := 3
	z := "sheena"
	u := true

	fmt.Println("x的type为：", reflect.TypeOf(x))
	fmt.Println("y的type为：", reflect.TypeOf(y))
	fmt.Println("z的type为：", reflect.TypeOf(z))
	fmt.Println("u的type为：", reflect.TypeOf(u))
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

结果：

(2) 进行变量类型判断

方法：xtype := reflect.TypeOf(x) xkind := xtype.Kind() if xkind == reflect.Type

作用：先调用TypeOf方法获取到x的类型信息，再获取到类型信息中的类型，与类型进行判断

package main

import (
	"fmt"
	"reflect"
)

func main(){
	x := 3.1415
	y := 3
	z := "sheena"
	u := true

	//获取变量的类型
	xtype := reflect.TypeOf(x)
	ytype := reflect.TypeOf(y)
	ztype := reflect.TypeOf(z)
	utype := reflect.TypeOf(u)

	//Kind()方法的返回结果主要是用来进行类型判断的
	xkind := xtype.Kind()
	ykind := ytype.Kind()
	zkind := ztype.Kind()
	ukind := utype.Kind()

	//对x进行类型判断
	if xkind == reflect.String{
		fmt.Println("x的type是string")
	}else if xkind == reflect.Float64{
		fmt.Println("x的type是float64")
	}

	//对y进行类型判断
	if ykind == reflect.Float64{
		fmt.Println("y的type是Float64")
	}else if ykind == reflect.Int{
		fmt.Println("y的type是int")
	}

	//对z进行类型判断
	if zkind == reflect.Float64{
		fmt.Println("z的type是Float64")
	}else if zkind == reflect.String{
		fmt.Println("z的type是string")
	}

	//对u进行类型判断
	if ukind == reflect.Bool{
		fmt.Println("u的type是bool")
	}else if ukind == reflect.String{
		fmt.Println("u的type是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
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

结果：

(3) 获取到变量值

方法：reflect.ValueOf(x)

作用：获取x变量的值

package main

import (
	"fmt"
	"reflect"
)

func main(){
	x := 3.1415
	y := 3
	z := "sheena"
	u := true

	fmt.Println("x的value为：", reflect.ValueOf(x))
	fmt.Println("y的value为：", reflect.ValueOf(y))
	fmt.Println("z的value为：", reflect.ValueOf(z))
	fmt.Println("u的value为：", reflect.ValueOf(u))
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

结果：

(4) 修改变量值

方法一：使用具体类型的值的设置方法，如SetString()、SetFloat64()等（可直接接收具体要修改的值）

package main

import (
	"fmt"
	"reflect"
)

func main(){
	x := 3.1415
	y := 3
	z := "sheena"
	u := true

	fmt.Println("x修改前的value为：", reflect.ValueOf(x))
	fmt.Println("y修改前的value为：", reflect.ValueOf(y))
	fmt.Println("z修改前的value为：", reflect.ValueOf(z))
	fmt.Println("u修改前的value为：", reflect.ValueOf(u))

	//通过反射传入变量x的地址，并且通过Ele
	rex := reflect.ValueOf(&x).Elem()
	rey := reflect.ValueOf(&y).Elem()
	rez := reflect.ValueOf(&z).Elem()
	reu := reflect.ValueOf(&u).Elem()

	//判断是否可以修改变量x的值，若可以，则用SetFLoat64()方法进行修改
	if rex.CanSet(){
		rex.SetFloat(61.23466)
		fmt.Println("x修改后的value为：", reflect.ValueOf(x))
	}else {
		fmt.Println("该变量不能修改")
	}

	if rey.CanSet(){
		rey.SetInt(10000)
		fmt.Println("y修改后的value为：", reflect.ValueOf(y))
	}else {
		fmt.Println("该变量不能修改")
	}

	if rez.CanSet(){
		rez.SetString("hello world")
		fmt.Println("z修改后的value为：", reflect.ValueOf(z))
	}else{
		fmt.Println("该变量不能修改")
	}

	if reu.CanSet(){
		reu.SetBool(false)
		fmt.Println("u修改后的value为：", reflect.ValueOf(u))
	}else {
		fmt.Println("该变量不能修改")
	}
}
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
42
43
44
45
46
47
48
49
50
51
52
53

结果：

方法二：是用Set方法直接设置值（注意set方法接收的是ValueOf的返回值）

package main

import (
	"fmt"
	"reflect"
)

func main(){
	x := 3.1415
	y := 3
	z := "sheena"
	u := true

	fmt.Println("x修改前的value为：", reflect.ValueOf(x))
	fmt.Println("y修改前的value为：", reflect.ValueOf(y))
	fmt.Println("z修改前的value为：", reflect.ValueOf(z))
	fmt.Println("u修改前的value为：", reflect.ValueOf(u))

	//通过反射传入变量x的地址，并且通过Ele
	rex := reflect.ValueOf(&x).Elem()
	rey := reflect.ValueOf(&y).Elem()
	rez := reflect.ValueOf(&z).Elem()
	reu := reflect.ValueOf(&u).Elem()

	//判断是否可以修改变量x的值，若可以，则用Set()方法进行修改
	if rex.CanSet(){
		ax := reflect.ValueOf(61.23466) // 使用Set方法修改值，Set方法接收的是ValueOf的返回值
		rex.Set(ax)
		fmt.Println("x修改后的value为：", reflect.ValueOf(x))
	}else {
		fmt.Println("该变量不能修改")
	}

	if rey.CanSet(){
		ay := reflect.ValueOf(10000)// 使用Set方法修改值，Set方法接收的是ValueOf的返回值
		rey.Set(ay)
		fmt.Println("y修改后的value为：", reflect.ValueOf(y))
	}else {
		fmt.Println("该变量不能修改")
	}

	if rez.CanSet(){
		az := reflect.ValueOf("hello world")// 使用Set方法修改值，Set方法接收的是ValueOf的返回值
		rez.Set(az)
		fmt.Println("z修改后的value为：", reflect.ValueOf(z))
	}else{
		fmt.Println("该变量不能修改")
	}

	if reu.CanSet(){
		au := reflect.ValueOf(false)// 使用Set方法修改值，Set方法接收的是ValueOf的返回值
		reu.Set(au)
		fmt.Println("u修改后的value为：", reflect.ValueOf(u))
	}else {
		fmt.Println("该变量不能修改")
	}
}
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
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

结果：

(5) 获取变量的指针所指向的对象

方法：Elem()方法

作用：获取变量x的指针所指向的对象

package main

import (
	"fmt"
	"reflect"
)

func main(){
	x := 3.1415
	y := 3
	z := "sheena"
	u := true

	//传入变量地址
	px := reflect.ValueOf(&x)
	py := reflect.ValueOf(&y)
	pz := reflect.ValueOf(&z)
	pu := reflect.ValueOf(&u)

	fmt.Println("x的地址是", px)
	fmt.Println("y的地址是", py)
	fmt.Println("z的地址是", pz)
	fmt.Println("u的地址是", pu)

	//通过变量地址获取到变量的值
	xe := px.Elem()
	ye := py.Elem()
	ze := pz.Elem()
	ue := pu.Elem()
	
	fmt.Println("x的值是", xe)
	fmt.Println("y的值是", ye)
	fmt.Println("z的值是", ze)
	fmt.Println("u的值是", ue)
}
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

结果：

(6) 获取结构体变量的类型和值

package main

import (
	"fmt"
	"reflect"
)

type Stu struct{
	Name string
	Age int
	Sex string
	IsCan bool
}

func main(){
	s1 := Stu{Name: "王一", Age: 18, Sex: "男", IsCan: false}
	s2 := Stu{Name: "王二", Age: 19, Sex: "女", IsCan: true}
	s3 := Stu{Name: "张三", Age: 20, Sex: "男", IsCan: false}

	//反射获取结构体的类型和值
	fmt.Println("s1的类型", reflect.TypeOf(s1))
	fmt.Println("s1的值", reflect.ValueOf(s1))

	fmt.Println("s2的类型", reflect.TypeOf(s2))
	fmt.Println("s2的值", reflect.ValueOf(s2))

	fmt.Println("s3的类型", reflect.TypeOf(s3))
	fmt.Println("s3的值", reflect.ValueOf(s3))


	fmt.Println("TypeOf()和Kind()方法输出的区别")
	fmt.Println("TypeOf(s1)：", reflect.TypeOf(s1))
	s1tp := reflect.TypeOf(s1)
	fmt.Println("Kind(s1)：", s1tp.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

结果：
在这里插入图片描述

二、反射的原理

1.反射如何获取类型信息

reflect包中提供TypeOf接口用于获取一个变量的类型信息。它接收一个空接口类型的参数，并返回一个reflect.Type类型的返回值

TypeOf接口：

func TypeOf(i interface{}) Type{
	eface := *(*emptyInterface)(unsafe.Pointer(&i))
	return toType(eface.type)
}

//Type接口提供了一系列方法
type Type interface{
	Align()  int                      //对齐边界
	FieldAlign()  int
	Method(int) Method
	MethodByName(string)  (Method, bool)       //方法
	NumMethod()  int         //类型名称
	Name()  string
	PkgPath()  string         //包路径
	Slize()  uintptr
	String()  string
	Kind()  Kind
	Implements(u Type)  bool         //是否实现指定接口
	AssginableTo(u Type)  bool
	ConvertibleTo(u Type)  bool
	Comparable()  bool                //是否可比较
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

2.反射如何修改变量值

用反射修改变量值，需要用到reflect.Value类型了，如下所示结构体，有三个元素，type字段存储反射变量的类型元数据指针；ptr字段存储数据地址；flag字段是一个位标识符，存储反射变量的描述信息，例如是否为指针，是否为方法或是否只读等等。
```
type Value struct {
      type *rtype
      ptr unsafe.Pointer
      flag
}

func ValueOf(i interface{}) Value{
      if i == nill{
           return Value()
      }
      escapes(i)
      return unpackEface(i)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
```
通常会有reflect.ValueOf方法来拿到反射类型的值，注意这里的参数i和TypeOf函数一样是个空接口类型，所以处理方式一样。（编译阶段会增加一个临时变量作为拷贝）

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/IT小白/article/detail/164122