go语言系列-反射

目录

  • 反射

    • 引出反射
    • 使用反射机制，编写函数的适配器，桥连接
    • 反射的应用场景
    • 反射重要的函数和概念
    • 反射的快速入门
    • 反射的注意事项和细节
    • 反射练习
    • 反射最佳实践

反射

  1. 反射可以在运行时动态获取变量的各种信息，比如变量的类型(type)，类别(kind)

  2. 如果是结构体变量，还可以获取到结构体本身的信息(包括结构体的字段、方法)
  3. 通过反射，可以修改变量的值，可以调用关联的方法
  4. 使用反射，需要import(“reflect”)

引出反射

import (
   "encoding/json"
   "fmt"
)
type Monster struct {
   Name string `json:"monsterName"`
   Age int `json:"monsterAge"`
   Sal float64 `json:"monsterSal"`
   Sex string `json:"monsterSex"`
}
func main()  {
   m := Monster{
      Name : "玉兔精",
      Age : 20,
      Sal : 888.99,
      Sex : "female",
   }
   data,_ := json.Marshal(m)
   fmt.Println("json result:", string(data))
}

输出结果：json result: {"monsterName":"玉兔精","monsterAge":20,"monsterSal":888.99,"monsterSex":"female"}思考问题：为什么

思考问题：

为什么序列化后，key - val的key值是结构体Tag的值，而不是字段的名称，比如：不是Name 而是:"monsterName":"玉兔精"

引出反射

使用反射机制，编写函数的适配器，桥连接

反射的应用场景

反射常见应用场景有以下两种

  1. 不知道接口调用哪个函数，根据传入参数在运行时确定调用的具体接口，这种需要对函数或方法反射。例如以下这种桥接模式，比如前面提出的问题
func bridge(funcPtr interface{}, args ...interface{})

第一个参数funcPtr以接口的形式传入函数指针，函数参数args以可变参数的形式传入，bridge函数中可以用反射来动态执行funcPtr函数

  1. 对结构体序列化时，如果结构体有指定Tag，也会使用到反射生成对应的字符串
type Monster struct {
   Name string `json:"monsterName"`
   Age int `json:"monsterAge"`
   Sal float64 `json:"monsterSal"`
   Sex string `json:"monsterSex"`
}

反射重要的函数和概念

  1. reflect.TypeOf(变量名)，获取变量的类型，返回reflect.Type类型
  2. reflect.ValueOf(变量名)，获取变量的值，返回reflect.Value类型reflect.Value是一个结构体类型。通过reflect.Value，可以获取到关于该变量的很多信息

    3）变量、interface{} 和 reflect.Value是可以相互转换的，这点在实际开发中，会经常使用到。画出示意图

反射的快速入门

编写一个案例，演示对(结构体、基本数据类型、interface{}、reflect.Value)进行反射的基本操作，代码演示

import (
   "fmt"
   "reflect"
)
//专门演示反射
func reflectTest01(b interface{}) {
   //通过反射获取的传入的变量的type,kind，值
   //1. 先获取到reflect.Type
   rTyp := reflect.TypeOf(b)
   fmt.Println("rTyp = ", rTyp)
   //2. 获取到reflect.Vakue
   rVal := reflect.ValueOf(b)
   n2 := 2 + rVal.Int()
   fmt.Println("n2 = ", n2)
   fmt.Printf("rVal = %v rVal type = %T\n", rVal, rVal)
   //下面将rVal 转成interface{}
   iV := rVal.Interface()
   //将interface{}通过断言转成需要的类型
   num2 := iV.(int)
   fmt.Println("num2 = ", num2)
}
//专门演示反射[对结构体的反射]
func reflectTest02(b interface{})  {
   //通过反射获取传入的变量的type,kind，值
   //1. 先获取到reflect.Type
   rTyp := reflect.TypeOf(b)
   fmt.Println("rTyp = ", rTyp)
   //2. 获取到reflect.Value
   rVal := reflect.ValueOf(b)

   //下面将rVal转成interface{}
   iV := rVal.Interface()
   fmt.Printf("iv = %v iv type = %T\n", iV, iV)
   //将interface{}通过断言转成需要的类型
   //这里，简单使用到检测的类型断言
   //也可以使用switch的断言形式来做的更加的灵活
   stu, ok := iV.(Student)
   if ok {
      fmt.Printf("stu.Name = %v\n", stu.Name)
   }
}

type Student struct {
   Name string
   Age int
}
type Monster struct {
   Name string
   Age int
}

func main()  {
   //演示对(结构体、基本数据类型、interface{}、reflect.Value)进行反射的基本操作
   //1. 先定义一个int
   var num int = 100
   reflectTest01(num)

   //2. 定义一个Student的实例
   stu := Student{
      Name : "tom",
      Age : 20,
   }
   reflectTest02(stu)
}
//rTyp =  int
//n2 =  102
//rVal = 100 rVal type = reflect.Value
//num2 =  100
//rTyp =  main.Student
//iv = {tom 20} iv type = main.Student
//stu.Name = tom

反射的注意事项和细节

1）reflect.Value.Kind 获取变量的类别，返回的是一个常量

2) Type和Kind的区别

? Type是类型，Kind是类别，Type和Kind可能是相同的，也可能是不同的

? 比如：var num int = 10 num的Type是int，Kind也是int

? 比如：var stu Student stu的Type是pKg1.Student，Kind是struct

  1. 通过反射可以让变量在interface{}和Reflect.Value之间相互转换，这点在前面画过示意图并在快速入门案例中讲解过，这里看下如何在代码中体现

  2. 使用反射的方式来获取变量的值(并返回对应的类型)，要求数据类型匹配，比如x是int，那么就应该使用reflect.Value(x).Int(),而不能使用其它的，否则报panic

  3. 通过反射来修改变量，注意当使用SetXxx方法来设置需要通过对应的指针类型来完成，这样才能改变传入的变量的值，同时需要使用到reflect.Value.Elem()方法
import (
   "fmt"
   "reflect"
)

func testInt(b interface{})  {
   val := reflect.ValueOf(b)
   fmt.Printf("val type = %T\n", val)
   val.Elem().SetInt(110)
   fmt.Printf("val = %v\n", val)
}
func main()  {
   var num int = 20
   testInt(&num)
   fmt.Println("num = ", num)
}
//val type = reflect.Value
//val = 0xc000054080
//num =  110
  1. reflect.Valut.Elem()应该如何理解

反射练习

  1. 给一个变量 var v float64 = 1.2 ，请使用反射来得到它的reflect.Value，然后获取对应的Type，Kind和值，并将reflect.Value转换成interface{}，再将interface{}转换成float64
  2. 看段代码，判断是否正确，为什么
import (
   "fmt"
   "reflect"
)

func main()  {
   var str string = "tom" // ok
   fs := reflect.ValueOf(&str) // ok fs -> string
   //fs.SetString("jack")  //error
   fs.Elem().SetString("jack")
   fmt.Printf("%v\n", str)
}
//jack

反射最佳实践

  1. 使用反射来遍历结构体的字段，调用结构体的方法，并获取结构体标签的值
import (
   "fmt"
   "reflect"
)
//定义一个Monster结构体
type Monster struct {
   Name  string `json:"name"`
   Age int `json:"monster_age"`
   Score float32 `json:"成绩"`
   Sex string
}
//方法，返回两个数的和
func (s Monster) GetSum(n1, n2 int) int {
   return n1 + n2
}
//方法，接收四个值，给s赋值
func (s Monster) Set(name string, age int, score float32, sex string) {
   s.Name = name
   s.Age = age
   s.Score = score
   s.Sex = sex
}
//方法，显示s的值
func (s Monster) Print() {
   fmt.Println("---start---")
   fmt.Println(s)
   fmt.Println("---end---")
}
func TestStruct(a interface{})  {
   //获取reflect.Type类型
   typ := reflect.TypeOf(a)
   //获取reflect.Value类型
   val := reflect.ValueOf(a)
   //获取到a对应的类别
   kd := val.Kind()
   //如果传入的不是struct，就退出
   if kd != reflect.Struct {
      fmt.Println("expect struct")
      return
   }
   //获取到该结构体有几个字段
   num := val.NumField()
   fmt.Printf("struct has %d fields \n", num) //4
   //变量结构体的所有字段
   for i := 0; i < num; i++ {
      fmt.Printf("Field %d: 值为=%v\n", i, val.Field(i))
      //获取到struct标签，注意需要通过reflect.Type来获取tag标签的值
      tagVal := typ.Field(i).Tag.Get("json")
      //如果该字段于tag标签就显示，否则就不显示
      if tagVal != "" {
         fmt.Printf("Field %d: tag 为 = %v\n", i, tagVal)
      }
   }
   //获取到该结构体有多少个方法
   numOfMethod := val.NumMethod()
   fmt.Printf("struct has %d methods \n", numOfMethod)
   //var params []reflect.Value
   //方法的排序默认是按照函数名的排序(ASCII码)
   val.Method(1).Call(nil)//获取到第二个方法，调用它

   //调用结构体的第1个方法Method(0)
   var params []reflect.Value //声明了[]reflect.Value
   params = append(params, reflect.ValueOf(10))
   params = append(params, reflect.ValueOf(40))
   res := val.Method(0).Call(params) // 传入的参数是[]reflect.Value ,返回[]reflect.Value
   fmt.Println("res = ", res[0].Int()) //返回结果，返回的结果是[]reflect.Value
}
func main()  {
   //创建了一个Monster实例
   var a Monster = Monster{
      Name: "黄鼠狼精",
      Age: 400,
      Score: 30.8,
   }
   //将Monster实例传递给TestStruct函数
   TestStruct(a)
}
//struct has 4 fields
//Field 0: 值为=黄鼠狼精
//Field 0: tag 为 = name
//Field 1: 值为=400
//Field 1: tag 为 = monster_age
//Field 2: 值为=30.8
//Field 2: tag 为 = 成绩
//Field 3: 值为=
//struct has 3 methods
//---start---
//{黄鼠狼精 400 30.8 }
//---end---
//res =  50
  1. 使用反射的方式来获取结构体的tag标签，遍历字段的值，修改字段值，调用结构体方法(要求：通过传递地址的方式完成，在前面案例上修改即可)
  2. 定义了两个函数test1和test2，定义一个适配器函数用作统一处理接口
  3. 使用反射操作任意结构体类型
  4. 使用反射创建并操作结构体
  5. 编写一个Cal结构体，有两个字段Num1和Num2
  6. 方法GetSub(name string)
  7. 使用反射遍历Cal结构体所有的字段信息
  8. 使用反射机制完成对GetSub的调用，输出形式为”tom 完成了减法运算，8 - 3 = 5”

原文地址：https://www.cnblogs.com/zisefeizhu/p/12643858.html

时间： 2024-08-01 00:22:20

go语言系列-反射的相关文章

Java语言中反射动态代理接口的解释与演示

Java语言中反射动态代理接口的解释与演示 Java在JDK1.3的时候引入了动态代理机制.可以运用在框架编程与平台编程时候捕获事件.审核数据.日志等功能实现,首先看一下设计模式的UML图解: 当你调用一个接口API时候,实际实现类继承该接口,调用时候经过proxy实现. 在Java中动态代理实现的两个关键接口类与class类分别如下: java.lang.reflect.Proxy java.lang.reflect.InvocationHandler 我们下面就通过InvocationHan

Java语言的反射机制 笔记 摘自 http://blog.csdn.net/kaoa000/article/details/8453371

在Java运行时环境中,对于任意一个类,能否知道这个类有哪些属性和方法?对于任意一个对象,能否调用它的任意一个方法?答案是肯定的.这种动态获取类的信息以及动态调用对象的方法的功能来自于Java 语言的反射(Reflection)机制. 1.Java 反射机制主要提供了以下功能: 在运行时判断任意一个对象所属的类.在运行时构造任意一个类的对象.在运行时判断任意一个类所具有的成员变量和方法.在运行时调用任意一个对象的方法 2.Reflection 是Java被视为动态(或准动态)语言的一个关键性质.

R语言系列：生成数据

R语言系列:生成数据 (2014-05-04 17:41:57) 转载▼ 标签: r语言 教育 分类: 生物信息 生成规则数据1.使用“:“,如x=1:10,注意该方法既可以递增也可以递减,如y=10:12.seq,有两种用法:①seq(起点,终点,步长); ②seq(length=9, from=1, to=5)    seq还有一种简写:seq(x)    #相当于1:length(x),但当length(x)为0时,返回integer(0)3.c(1,2,8)4.使用scan(),可以等待

Java记录 -83- Java语言的反射机制

Java语言的反射机制 在Java运行时环境中,对于任意一个类,能否知道这个类有哪些属性和方法?对于任意一个对象,能否调用它的任意一个方法?答案是肯定的.这种动态获取类的信息以及动态调用对象的方法的功能来自于Java语言的反射(Reflection)机制. Java反射机制主要提供了以下功能: 1. 在运行时判断任意一个对象所属的类: 2. 在运行时构造任意一个类的对象: 3. 在运行时判断任意一个类所具有的成员变量和方法: 4. 在运行时调用任意一个对象的方法: Reflection是java

C#基础系列 - 反射基础

反射用于在程序运行过程中,获取类里面的信息或发现程序集并运行的一个过程.通过反射可以获得.dll和.exe后缀的程序集里面的信息.使用反射可以看到一个程序集内部的类,接口,字段,属性,方法,特性等信息. 一.各种GetType().typeof的区别 首先就是获取Tyoe对象的来源不同: class Program { static void Main(string[] args) { Type t1 = Type.GetType("ConsoleApplication2.Person"

C语言系列教程完整版

下面是C语言所有完整的教程 C语言教程(一):程序开发理论基础 C语言教程(二):开发环境搭建 C语言教程(三):进制以及进制转换 C语言教程(四):常量.变量.数据类型 C语言教程(五):运算符和表达式 C语言教程(六):语句 C语言教程(七):分支语句之if语句 C语言教程(八):分支语句之switch语句 C语言教程(九):逻辑运算符 C语言教程(十):循环语句] C语言教程(十一):随机数以及随机数原理 C语言教程(十二):数组 C语言教程(十三):宏定义 C语言教程(十四):函数 C语

C#基础系列——反射笔记

前言:使用反射也有几年了,但是一直觉得,反这个概念很抽象,今天有时间就来总结下这个知识点. 1.为什么需要反射: 最初使用反射的时候,作为小菜总是不理解,既然可以通过new 一个对象的方式得到对象,然后通过对象去调用属性和方法,那么为什么还需要反射去调用呢?后来使用多了发现这就是一个先绑定还是后绑定的问题,很多初使用反射的开发人员通常都会有类似这种疑虑:既然在开发时就能够写好代码,干嘛还放到运行期去做,不光繁琐,而且效率也受影响.博主觉得主要是适用性的问题,如果你的系统没有那么高的扩展性和灵活性

C语言系列之强制类型转换（一）

例子: #include <stdio.h> { char cChar;   //字符型变量 short int iShort; //短整型变量 int ilnt;           //整形变量 float fFloat=70000;      //单精度浮点型 cChar=(char)fFloat;     //强制转换赋值 iShort=(short)fFloat;    // ilnt=(int)fFloat;           // printf("the char i

【R语言系列】作图入门示例一

假设有如下数据,我们使用plot函数作图 月龄 体重 月龄 体重  1 4.4 9 7.3 3 5.3 3 6.0 5 7.2 9 10.4 2 5.2 12 10.2 11 8.5 3 6.1 R语言中默认函数 abs   绝对值 sqrt   平方根 exp  e^x次方 log   自然对数 log2 log10  其他对数 sin  cos tan 三角函数 sinh cosh tanh  双曲函数 poly  正交多项式 polyroot  多项式求根 assign   赋值操作 等同