经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置:技术经验 » 程序设计 » Go语言 » 查看文章
Golang语言学习拿捏Go反射示例教程
来源:jb51  时间:2021/11/9 15:10:23  对本文有异议

1. 反射简介

1.1 反射是什么?

Go语言提供了一种机制在运行时更新和检查变量的值、调用变量的方法和变量支持的内在操作,但是在编译时并不知道这些变量的具体类型,这种机制被称为反射。反射也可以让我们将类型本身作为第一类的值类型处理。

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

举个例子
平时我们定义变量都是正射

  1. var a int

将变量a定义成一个int类型

现在我并不知道变量a是什么类型,但是我可以通过反射也知晓变量a是什么来历!是什么类型!

  1. type FanOne struct {
  2. name string
  3. }
  4. func main(){
  5. var a int = 1
  6. var d FanOne
  7. fmt.Println(reflect.TypeOf(a)) // int
  8. // 这里就拿到了a的类型!注意是类型!不是类别!虽然这个类型和类别是一样的
  9. // 后面会说说类型(Type)和类别(Kind)的区别
  10. fmt.Println(reflect.ValueOf(a).Kind()) //int
  11. //这样就拿到了a的类别,是通过a的值来判断类别
  12. fmt.Println(reflect.TypeOf(d)) //main.FanOne
  13. //类型是main.FanOne 是在main里面定义的FanOne
  14. fmt.Println(reflect.ValueOf(d).Kind()) //struct
  15. //类别是struct
  16. // 输出 d 的类型名称和种类,类型名称就是 FanOne
  17. //而 FanOne 属于一种结构体类别,因此类别为 struct
  18. }

所以这个类别和类型有时候相同,有时候不同。

1.2 为什么需要反射?

在开发当中,当我们对于某一个函数进行值的处理的时候,但是为了保证这个函数能接受更多类型的值,因为go是强类型的语言,虽然interface可以接受所有的数据类型,但是在处理数据的时候,要对不同类型进行不同的处理的时候就会显得代码十分冗余,于是我们可以使用反射来进行对传入参数的判断与处理。

详细见例题

2. reflect包

2.1 基本反射

  1. reflect.TypeOf() //获取变量的类型,返回reflect.Type类型
  2. reflect.ValueOf() //获取变量的值,返回reflect.Value类型
  3. reflect.Value.Kind() //获取变量的类别,返回一个常量
  4. reflect.Value.Interface() //转换成interface{}类型

2.2 反射与指针

Go语言程序中对指针获取反射对象时,可以通过 reflect.Elem() 方法获取这个指针指向的元素类型,这个获取过程被称为取元素,等效于对指针类型变量做了一个*操作

  1. reflect.ValueOf(xxx).Elem()

2.3 反射与对象

可以通过reflect.new(xxx)或是reflect.zero(xxx)来进行反射,创建原始类型的对象

  1. func CreatePrimitiveObjects(t reflect.Type) reflect.Value {
  2. return reflect.Zero(t)
  3. }

也可以使用

  1. reflect.New()

来进行创建原始对象。

2.4 反射与函数

如果反射值对象(reflect.Value)中值的类型为函数时,可以通过reflect.Value调用该函数。使用反射调用函数时,需要将参数使用反射值对象的切片[]reflect.Value构造后传入Call()方法中,调用完成时,函数的返回值通过[]reflect.Value返回。
在反射中 函数 和 方法 的类型(Type)都是 reflect.Func,如果要调用函数的话,可以通过 Value 的 Call() 方法,例如:

  1. package main
  2.  
  3. import (
  4. "fmt"
  5. "reflect"
  6. )
  7.  
  8. func FanOne() string {
  9. return "一键三连"
  10. }
  11.  
  12. func FanOneWoW(a string) string {
  13. return fmt.Sprintf("%s要给FanOne一键三连噢~",a)
  14. }
  15.  
  16. func main() {
  17. FanOneNotArgs := reflect.ValueOf(FanOne).Call([]reflect.Value{}) //无参数
  18. FanOneHaveArgs := reflect.ValueOf(FanOneWoW).Call([]reflect.Value{reflect.ValueOf("我")}) //有参数
  19. fmt.Println(FanOneNotArgs[0])
  20. fmt.Println(FanOneHaveArgs[0])
  21. }
  22.  

2.5 反射例子

填写fn函数使得输出为

在这里插入图片描述

要求不使用任何的switch 或是 if 或是其他选择语句。

  1. func fn(callback interface{}, bytes []byte) {
  2. //coding
  3. }
  4. type aaa struct {
  5. Name string `json:"name"`
  6. Age int `json:"age"`
  7. }
  8. func Test(t *testing.T) {
  9. fn(func(a []*aaa) string {
  10. aaas := a
  11. for i, item := range aaas {
  12. fmt.Println(i, item)
  13. }
  14. fmt.Println("12312312, ", aaas)
  15. return "xxxx"
  16. }, []byte("[{\"name\":\"111\",\"age\":1}, {\"name\":\"gsjk\",\"age\":2}]"))
  17.  
  18. fn(func(a []aaa) string {
  19. aaas := a
  20. for i, item := range aaas {
  21. fmt.Println(i, item)
  22. }
  23.  
  24. fmt.Println("12312312, ", aaas[0])
  25. return "xxxx"
  26. }, []byte("[{\"name\":\"111\",\"age\":1}, {\"name\":\"gsjk\",\"age\":2}]"))
  27.  
  28. fn(func(a *aaa) string {
  29. fmt.Println("12312312, ", a)
  30. aaas := a
  31. fmt.Println("12312312, ", aaas)
  32. return "xxxx"
  33. }, []byte("{\"name\":\"gsjk\",\"age\":2}"))
  34.  
  35. fn(func(a string) string {
  36. fmt.Println("12312312, ", a)
  37. aaas := a
  38. fmt.Println("12312312, ", aaas)
  39. return "xxxx"
  40. }, []byte("\"sss\""))
  41.  
  42. fn(func(a int) string {
  43. fmt.Println("-----------, ", a)
  44. aaas := a
  45. fmt.Println("-----------, ", aaas)
  46. return "xxxx"
  47. }, []byte("123"))
  48. }

(1)首先是test的知识:
名称一定要有_test,不然好像会报错,我就是这样。

  1. go test xxx_test.go
  2. go test -v xxx_test.go

(2)其次是了解这个fn()里面的匿名函数
单独拿出来

  1. func(a []*aaa) string {
  2. aaas := a
  3. for i, item := range aaas {
  4. fmt.Println(i, item)
  5. }
  6. fmt.Println("12312312, ", aaas)
  7. return "xxxx"
  8. }, []byte("[{\"name\":\"111\",\"age\":1}, {\"name\":\"gsjk\",\"age\":2}]"))

可以看到这是一个*aaa类型的数组。那么我们任务就是反射出fn这个函数里面的匿名函数,然后调用反射出来的这个匿名函数,并将参数传入其中。

以下都是用第一个作为例子

(3)那么我们先ValueOf和TypeOf这个interface{},然后再看这个匿名函数各种的值

  1. func fn(callback interface{}, bytes []byte) {
  2. v := reflect.ValueOf(callback) //0xbaff40
  3. t := reflect.TypeOf(callback) //func([]*main.aaa) string
  4. }

我们可以看到入参的函数的Type是func([]*main.aaa) string 所以我们可以用

  1. paramsValue := t.In(0) //[]*main.aaa

拿到匿名函数的传入参数

(4)重点!!
我们拿到的这个paramsValue只是[]*main.aaa名称,这个值是reflect.type 类型的!!、
我们要的是[]*main.aaa这个类型,而不是要这个名称!
所以我们要创建这个类型的对象,然后转成相应的类型

  1. val := reflect.New(paramsValue)
  2. newT := val.Interface()
  3. fmt.Printf("valValue:%v , valType: %T \n",val,val) //valValue:&[] , valType: reflect.Value
  4. fmt.Printf("newTValue:%v , newTType: %T \n",newT,newT)//newTValue:&[] , newTType: *[]*main.aaa

我们要创建这样一个类别的对象,虽然go并不是面向对象的编程,但是这里可以这样理解。

为什么要这个类型呢?

因为后面把bytes切片反序列化成这个类型的变量,传入这个匿名函数中!

  1. if v.IsValid() { //function valid or not
  2. _ = json.Unmarshal(bytes, newT) //byte to json
  3. }

那么问题又来了,传入的值的类型是[]*main.aaa 但是我们拿到了*[]*main.aaa这个类型,很明显是不对的。

  1. fmt.Printf("调用 callback 结束 callback ret = %s \n", v.Call([]reflect.Value{reflect.ValueOf(newT)}))
  2. fmt.Printf("*************************\n")

报错了!类型不对!

那么我们就要进行去*操作。在反射中,并不是直接加*去除!下面这样在反射中是不行的。

  1. package main
  2.  
  3. import (
  4. "fmt"
  5. "reflect"
  6. )
  7.  
  8. func main(){
  9. var a int = 1
  10. var b *int = &a
  11. var c **int = &b
  12. fmt.Println(a, *b, c)
  13. fmt.Println(reflect.TypeOf(a))
  14. fmt.Println(reflect.TypeOf(*b))
  15. fmt.Println(reflect.TypeOf(b))
  16. }

那么我们可以用reflect.Elem() 将这个去除*

  1. fmt.Printf("调用 callback 结束 callback ret = %s \n", v.Call([]reflect.Value{reflect.ValueOf(newT).Elem()}))
  2. fmt.Printf("*************************\n")

大功告成了!

3. 总结

以前我是很少使用反射的,基本在项目中就没用过,但是暑期实习的时候,第一个任务就是写反射接口,那么就疯狂补这方面的知识,反射对于我来说,确实有点难理解,花了我两天时间才做出来。

原来我的想法是用if判断类型的,或是断言然后用switch判断类型的,但是这样实用性不高,换了一个名称的话就要改代码了。比如现在是结构体aaa,换成bbb就不管用了。

现在这种的话,直接将这个类型的反射成一个对象,然后再对这个对象进行赋值操作,就更加灵活!

学到了!

实习很痛苦!但是学到了很多新知识!还有好多大佬带!还有工资拿!也舒服!

以上就是Golang语言学习拿捏Go反射示例教程的详细内容,更多关于Go反射教程的资料请关注w3xue其它相关文章!

 友情链接:直通硅谷  点职佳  北美留学生论坛

本站QQ群:前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

W3xue 的所有内容仅供测试,对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接(目前9元/月)请联系QQ:27243702 沸活量
皖ICP备17017327号-2 皖公网安备34020702000426号