Golang语言学习拿捏Go反射示例教程

1. 反射简介

1.1 反射是什么？

具体类型反射

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

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

var a int

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

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

type FanOne struct {    name string}func main(){        var a int = 1    var d FanOne    fmt.Println(reflect.TypeOf(a))            // int     // 这里就拿到了a的类型！注意是类型！不是类别！虽然这个类型和类别是一样的    // 后面会说说类型(Type)和类别(Kind)的区别    fmt.Println(reflect.ValueOf(a).Kind())    //int     //这样就拿到了a的类别，是通过a的值来判断类别    fmt.Println(reflect.TypeOf(d))            //main.FanOne    //类型是main.FanOne  是在main里面定义的FanOne    fmt.Println(reflect.ValueOf(d).Kind())    //struct    //类别是struct    // 输出 d 的类型名称和种类，类型名称就是 FanOne    //而 FanOne 属于一种结构体类别，因此类别为 struct}

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

1.2 为什么需要反射？

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

详细见例题

2. reflect包

2.1 基本反射

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

2.2 反射与指针

reflect.Elem()*

reflect.ValueOf(xxx).Elem()

2.3 反射与对象

reflect.new(xxx)reflect.zero(xxx)

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

也可以使用

reflect.New()

来进行创建原始对象。

2.4 反射与函数

（reflect.Value）reflect.Value[]reflect.ValueCall()[]reflect.Value

package mainimport (    "fmt"    "reflect")func FanOne() string {    return "一键三连"}func FanOneWoW(a string) string {    return fmt.Sprintf("%s要给FanOne一键三连噢~",a)}func main() {    FanOneNotArgs := reflect.ValueOf(FanOne).Call([]reflect.Value{})         //无参数    FanOneHaveArgs := reflect.ValueOf(FanOneWoW).Call([]reflect.Value{reflect.ValueOf("我")})  //有参数    fmt.Println(FanOneNotArgs[0])    fmt.Println(FanOneHaveArgs[0])}

2.5 反射例子

填写fn函数使得输出为

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

func fn(callback interface{}, bytes []byte) {        //coding}type aaa struct {    Name string `json:"name"`    Age  int    `json:"age"`}func Test(t *testing.T) {        fn(func(a []*aaa) string {        aaas := a        for i, item := range aaas {            fmt.Println(i, item)        }        fmt.Println("12312312, ", aaas)        return "xxxx"    }, []byte("[{\"name\":\"111\",\"age\":1}, {\"name\":\"gsjk\",\"age\":2}]"))    fn(func(a []aaa) string {        aaas := a        for i, item := range aaas {            fmt.Println(i, item)        }        fmt.Println("12312312, ", aaas[0])        return "xxxx"    }, []byte("[{\"name\":\"111\",\"age\":1}, {\"name\":\"gsjk\",\"age\":2}]"))    fn(func(a *aaa) string {        fmt.Println("12312312, ", a)        aaas := a        fmt.Println("12312312, ", aaas)        return "xxxx"    }, []byte("{\"name\":\"gsjk\",\"age\":2}"))    fn(func(a string) string {        fmt.Println("12312312, ", a)        aaas := a        fmt.Println("12312312, ", aaas)        return "xxxx"    }, []byte("\"sss\""))    fn(func(a int) string {        fmt.Println("-----------, ", a)        aaas := a        fmt.Println("-----------, ", aaas)        return "xxxx"    }, []byte("123"))}

（1）首先是test的知识：
名称一定要有_test，不然好像会报错，我就是这样。

go test xxx_test.gogo test -v xxx_test.go

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

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

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

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

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

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

func([]*main.aaa) string

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

拿到匿名函数的传入参数

paramsValue[]*main.aaareflect.type[]*main.aaa

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

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

为什么要这个类型呢？

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

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

[]*main.aaa*[]*main.aaa

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

报错了！类型不对！

**

package mainimport (  "fmt"  "reflect")func main(){  var a int = 1  var b *int = &a  var c **int = &b  fmt.Println(a, *b, c)  fmt.Println(reflect.TypeOf(a))  fmt.Println(reflect.TypeOf(*b))  fmt.Println(reflect.TypeOf(b))}

reflect.Elem()*

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

大功告成了！

3. 总结

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

if断言switch

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

学到了！

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

原文链接：https://blog.csdn.net/weixin_45304503/article/details/118679368