【Go】二十、反射

水深无声 2024-04-23 15:45 79阅读 0赞

#### 文章目录 ####

*  1、反射
 *  2、对基本数据类型反射
 *  3、对结构体进行反射
 *  4、获取变量的类别
 *  5、通过反射修改基本类型变量的值
 *  6、通过反射操作结构体的属性和方法

## 1、反射 ##

//核心包
    import ("reflect")

通过反射：

*  可以在运行时动态获取变量的类型、获取结构体的信息（字段、方法）
 *  可以修改变量的值，调用关联的方法

相关函数：

//作用：反射获取变量的类型
    //返回类型是reflect.Type类型
    reflect.TypeOf(变量名)

//作用：反射获取变量的值
    //返回reflect.Value类型(reflect.Value是一个结构体类型),通过reflect.Value，可以获取到关于该变量的很多信息
    reflect.ValueOf(变量名)

## 2、对基本数据类型反射 ##

空接口没有任何方法,所以可以理解为所有类型都实现了空接口，也可以理解为可以把任何一个变量赋给空接口。有点像Object类

package main
    import(
            "fmt"
            "reflect"
    )
    //利用一个函数，函数的参数定义为空接口：
    func testReflect(i interface{
        }){
        
    
            //1.调用TypeOf函数，返回reflect.Type类型数据：
            reType := reflect.TypeOf(i)			//拿类型
            fmt.Println("reType:",reType)
            fmt.Printf("reType的具体类型是：%T",reType)
            fmt.Println()
            
            //2.调用ValueOf函数，返回reflect.Value类型数据：
            reValue :=reflect.ValueOf(i)
            fmt.Println("reValue:",reValue)		//拿值
            fmt.Printf("reValue的具体类型是：%T",reValue)
            fmt.Println()
            
            //如果真想获取reValue的数值，要调用Int()方法：返回v持有的有符号整数
            num := reValue.Int()
            fmt.Printf("Int()后的类型是：%T",num)
            fmt.Println()
            
            //reflect.Value类型数据，转回去，可先将reValue转成空接口，再用断言转型：
            i2 := reValue.Interface()
            //类型断言：
            n := i2.(int)
            n2 := n + 30
            fmt.Println(n2)
    }
    
    
    func main(){
        
            //对基本数据类型进行反射：
            //定义一个基本数据类型：
            var num int = 100
            testReflect(num)
    }

运行：

![在这里插入图片描述][7020d2e498484aac9b2f4171472c8433.png]

注意点：如果有了reflect.Value类型，想转回原来的类型，可以用reflect.Value类型的Interface方法，转回空接口类型，再断言转型，回到int类型

![在这里插入图片描述][6d050e2a536541edb0526cb4d3e4c4aa.png]

## 3、对结构体进行反射 ##

package main
    import(
            "fmt"
            "reflect"
    )
    //利用一个函数，函数的参数定义为空接口：
    func testReflect(i interface{
        }){
        
            //1.调用TypeOf函数，返回reflect.Type类型数据：
            reType := reflect.TypeOf(i)
            fmt.Println("reType:",reType)
            fmt.Printf("reType的具体类型是：%T",reType)
            fmt.Println()
            //2.调用ValueOf函数，返回reflect.Value类型数据：
            reValue :=reflect.ValueOf(i)
            fmt.Println("reValue:",reValue)
            fmt.Printf("reValue的具体类型是：%T",reValue)
            fmt.Println()
            //reValue转成空接口：
            i2 := reValue.Interface()
            //类型断言：
            n,flag := i2.(Student)
            if flag == true {
        //断言成功
                    fmt.Printf("学生的名字是：%v,学生的年龄是：%v",n.Name,n.Age)
            }
            
    }
    //定义学生结构体：
    type Student struct{
        
            Name string
            Age int
    }
    func main(){
        
            //对结构体类型进行反射：
            //定义结构体具体的实例：
            stu := Student{
        
                    Name : "丽丽",
                    Age : 18,	
            }
            //反射
            testReflect(stu)
    }

运行：

![在这里插入图片描述][fb34b21de0364ba6a816b3baa68b0e06.png]

## 4、获取变量的类别 ##

在上面reflect.Type和reflect.Value类型对象的基础上，获取类别（Student是类型，其类别是struct结构体）。相关方法：

reflect.Type.Kind()
    reflect.Value.Kind()

![在这里插入图片描述][0366be64443a439cb7870dc9379fefcc.png]

package main
    import(
            "fmt"
            "reflect"
    )
    //利用一个函数，函数的参数定义为空接口：
    func testReflect(i interface{
        }){
        //空接口没有任何方法,所以可以理解为所有类型都实现了空接口，也可以理解为我们可以把任何一个变量赋给空接口。
            //1.调用TypeOf函数，返回reflect.Type类型数据：
            reType := reflect.TypeOf(i)
            //2.调用ValueOf函数，返回reflect.Value类型数据：
            reValue :=reflect.ValueOf(i)
            //获取变量的类别：
            //（1）reType.Kind()
            k1 := reType.Kind()
            fmt.Println(k1)
            //（2）reValue.Kind()
            k2 := reValue.Kind()
            fmt.Println(k2)
            //获取变量的类型：
            //reValue转成空接口：
            i2 := reValue.Interface()
            //类型断言：
            n,flag := i2.(Student)
            if flag == true {
        //断言成功
                    fmt.Printf("结构体的类型是：%T",n)
            }
    }
    //定义学生结构体：
    type Student struct{
        
            Name string
            Age int
    }
    func main(){
        
            //对结构体类型进行反射：
            //定义结构体具体的实例：
            stu := Student{
        
                    Name : "丽丽",
                    Age : 18,	
            }
            testReflect(stu)
    }

运行：

![在这里插入图片描述][5faf4e7d18a14537b08dba7590b06705.png]  
类型Type和类别Kind的区别：

var num int = 10 num的Type是int , Kind也是int 
    ar stu Studentstu的 Type是 pkg1.Student , Kind是struct

## 5、通过反射修改基本类型变量的值 ##

调用reflect.Value的相关方法，SetInt、SetBoolean等等

package main
    import(
            "fmt"
            "reflect"
    )
    //利用一个函数，函数的参数定义为空接口：
    func testReflect(i interface{
        }){
        //空接口没有任何方法,所以可以理解为所有类型都实现了空接口，也可以理解为我们可以把任何一个变量赋给空接口。
            reValue :=reflect.ValueOf(i)
            //通过SetInt()来改变值：
            reValue.Elem().SetInt(40)
            
    }
    func main(){
        
            //对基本数据类型进行反射：
            //定义一个基本数据类型：
            var num int = 100
            testReflect(&num) //传入指针地址
            fmt.Println(num)	//40
    }

注意，是改基本类型变量，值拷贝，要传入地址：

testReflect(&num)

因为传入的是一个指针类型，想调用reflect.Value的相关方法，对上面的reValue 变量也得再转一下：

reValue.Elem().SetInt(40)

![在这里插入图片描述][0366a9638a9d499395b117796c30a465.png]

## 6、通过反射操作结构体的属性和方法 ##

和Java一样，获取所有的变量和所有的方法，调用方法，方法的首字母必须大写才能有对应的反射的访问权限。相关方法：

*  NumField：获取结构体字段的总数
 *  Field：获取结构体的某一个字段，传i序号0、1、2
 *  NumMethod：获取结构体中方法的数量
 *  Method：获取结构体中的某一个方法，传i序号0、1、2
 *  Call，反射调用方法，形参是一个切片，即调用方法的形参

package main
    import(
            "fmt"
            "reflect"
    )
    //定义一个结构体：
    type Student struct{
        
            Name string
            Age int
    }
    //给结构体绑定方法：
    func (s Student) CPrint(){
        
            fmt.Println("调用了Print()方法")
            fmt.Println("学生的名字是：",s.Name)
    }
    func (s Student) AGetSum(n1,n2 int) int{
        
            fmt.Println("调用了AGetSum方法")
            return n1 + n2
    }
    func (s Student) BSet(name string,age int){
        
            s.Name = name
            s.Age = age
    }
    
    
    
    //定义函数操作结构体进行反射操作：
    func TestStudentStruct(a interface{
        }){
        
            //a转成reflect.Value类型：
            val := reflect.ValueOf(a)
    
            //通过reflect.Value类型操作结构体内部的字段个数：
            n1 := val.NumField()
            fmt.Println(n1)		//2
            
            //遍历-获取具体的字段的值：
            for i := 0; i < n1;i++{
        
                    fmt.Printf("第%d个字段的值是：%v",i,val.Field(i))
            }
            fmt.Println()
    
            //通过reflect.Value类型操作结构体内部的方法个数：
            n2 := val.NumMethod()
            fmt.Println(n2)
            
            //调用自定义结构体的CPrint()方法：
            //调用方法，方法的首字母必须大写才能有对应的反射的访问权限
            //方法的顺序按照ASCII的顺序排列的，a,b,c,,,,,,索引：0,1,2，，，，，
            val.Method(2).Call(nil)	//nil给反射的那个方法传空参
            
            //调用AGetSum方法：
            //定义Value的切片：
            var params []reflect.Value
            params = append(params,reflect.ValueOf(10))
            params = append(params,reflect.ValueOf(20))
            result := val.Method(0).Call(params)
            fmt.Println("AGetSum方法的返回值为：",result[0].Int())
    }
    
    
    func main(){
        
            //定义结构体具体的实例：
            s := Student{
        
                    Name : "丽丽",
                    Age : 18,
            }
            //调用TestStudentStruct反射：
            TestStudentStruct(s)
    }

修改结构体属性的值：

package main
    import(
            "fmt"
            "reflect"
    )
    
    //定义函数操作结构体进行反射操作：
    func TestStudentStruct(a interface{
        }){
        
            //a转成reflect.Value类型：
            val := reflect.ValueOf(a)
            fmt.Println(val)
            n := val.Elem().NumField()
            fmt.Println(n)
            //修改字段的值：
            val.Elem().Field(0).SetString("张三")		注意点2
    }
    
    
    func main(){
        
            //定义结构体具体的实例：
            s := Student{
        
                    Name : "丽丽",
                    Age : 18,
            }
            //调用TestStudentStruct：
            TestStudentStruct(&s)		注意点1
            fmt.Println(s)
    }

[7020d2e498484aac9b2f4171472c8433.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/2fd36905b1e0440386069c30c3543db8.png
[6d050e2a536541edb0526cb4d3e4c4aa.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/10dc9c3af6f04980a9fc9f4227f6b972.png
[fb34b21de0364ba6a816b3baa68b0e06.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/db341baa90a144f5b65c235b9a6c29fb.png
[0366be64443a439cb7870dc9379fefcc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/5ec38ac0925f4c8291a742f0acf3f7d6.png
[5faf4e7d18a14537b08dba7590b06705.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/813944b1bce845b3a3250f4c5fc98fb3.png
[0366a9638a9d499395b117796c30a465.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/7193a41623bb4e5fb017cce0bc7d35e8.png