Go——反射的使用

最新推荐文章于 2024-10-18 14:53:24 发布
最新推荐文章于 2024-10-18 14:53:24 发布
阅读量1.1k 收藏
点赞数 1
CC 4.0 BY-SA版权
文章标签： go golang 运维开发 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/LiuHuan303/article/details/124298038
本文详细介绍了Go语言中的反射机制，包括reflect包的使用，如valueOf、value.set、结构体和函数的反射，以及方法反射的调用。通过示例展示了如何获取变量类型、设置变量值、反射结构体属性和方法，以及如何反射调用函数和方法。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

目录

1，reflect

2，valueOf

3，value.set

4，结构体的反射

5，函数的反射

6，方法反射

概念:运行时动态的获取变量的相关信息。

反射:对一些对象进行序列化处理

Import ("reflect)

1，reflect

  1. reflect. TypeOf,获取变量的类型，返回reflect Type类型

  2. reflect ValueOf,获取变量的值，返回reflect .Value类型

  3. reflect.Value Kind, 获取变量的类别，返回一个常量

  4. reflect Value .Interface(),转换成interface{}类型

示例：获取变量类型

package main
​
import (
    "fmt"
    "reflect"
)
​
//定义一个函数
func Test(i interface{}) {
    //反射数据类型
    t := reflect.TypeOf(i)
    fmt.Println("类型是:", t)
    //反射数据值
    y := reflect.ValueOf(i)
    fmt.Println("类型是:", y)
}
​
func main() {
    a := "hello"
    Test(a)
}
[Running] go run "f:\goProject\src\dev_code\day23\example1\main.go"
类型是: string
类型是: hello
​
[Done] exited with code=0 in 0.73 seconds

示例：类型和类别

package main
​
import (
    "fmt"
    "reflect"
)
​
//类型和类别
//定义结构体
type student struct {
    name  string
    age   int
    score float32
}
​
//函数传入
func Test(i interface{}) {
    //反射数据类型
    t := reflect.TypeOf(i)
    fmt.Println("类型是:", t)
    //类别
    y := reflect.ValueOf(i) //或者u:=reflect.ValueOf(i).Kind()
    u := y.Kind()
    fmt.Println("值是：", y)
    fmt.Println("类别是：", u)     //类别是一个常量
​
}
​
func main() {
    var stu student
    stu.name = "zhangsan"
    stu.age = 20
    stu.score = 50
    Test(stu)
    fmt.Println("<<<--------我是华丽的分割线--------->>>")
    var num int = 10
    Test(num)
}
[Running] go run "f:\goProject\src\dev_code\day23\example2\main\main.go"
类型是: main.student
值是： {zhangsan 20 50}
类别是： struct
<<<--------我是华丽的分割线--------->>>
类型是: int   
值是： 10
类别是： int
​
[Done] exited with code=0 in 0.6 seconds

示例：断言处理类型转换

package main
​
import (
    "fmt"
    "reflect"
)
​
//类型和类别
//定义结构体
type student struct {
    name  string
    age   int
    score float32
}
​
//函数传入
func Test(i interface{}) {
    //反射数据类型
    t := reflect.TypeOf(i)
    fmt.Println("类型是:", t)
    //类别
    y := reflect.ValueOf(i) //或者u:=reflect.ValueOf(i).Kind()
    u := y.Kind()
    fmt.Println("类别是：", u) //类别是一个常量
    fmt.Printf("y的类型是%T\n", y)
    fmt.Printf("u的类型是%T\n", u)
    //转化成接口
    iy := y.Interface()
    fmt.Printf("iy的类型是%T\n", iy)
    //断言处理iy是student类型是true就赋值给stu_iy
    stu_iy, ok := iy.(student)
    if ok {
        fmt.Printf("stu_iy的类型是%T\n", stu_iy)
    }
}
​
func main() {
    var stu student
    stu.name = "zhangsan"
    stu.age = 20
    stu.score = 50
    Test(stu)
​
}
[Running] go run "f:\goProject\src\dev_code\day23\example2\main\main.go"
类型是: main.student
类别是： struct
y的类型是reflect.Value
u的类型是reflect.Kind
iy的类型是main.student
stu_iy的类型是main.student
​
[Done] exited with code=0 in 0.474 seconds

2，valueOf

获取变量值

reflect. Value0f(x)- Float()
reflect. Value0f(x).Int( )
reflect . ValueOf(x) . String( )
reflect . ValueOf(x). Bool()

示例：类型转换

package main
​
import (
    "fmt"
    "reflect"
)
​
//定义函数传入
func Test(i interface{}) {
    fmt.Printf("i的类型：%T\n", i)
    v := reflect.ValueOf(i)
    fmt.Printf("v的类型：%T\n", v)
    //转换指定类型
    t := v.Int()
    fmt.Printf("t的类型：%T\n", t)
}
func main() {
    var num int = 10
    Test(num)
}
[Running] go run "f:\goProject\src\dev_code\day23\example3\main\main.go"
i的类型：int
v的类型：reflect.Value
t的类型：int64
​
[Done] exited with code=0 in 0.616 seconds

不同类型会出错

package main
​
import (
    "fmt"
    "reflect"
)
​
//定义函数传入
func Test(i interface{}) {
    fmt.Printf("i的类型：%T\n", i)
    v := reflect.ValueOf(i)
    fmt.Printf("v的类型：%T\n", v)
    //转换指定类型
    t := v.Int()
    fmt.Printf("t的类型：%T\n", t)
}
func main() {
    var num string = "10"
    Test(num)
}
​
[Running] go run "f:\goProject\src\dev_code\day23\example3\main\main.go"
i的类型：string
v的类型：reflect.Value
panic: reflect: call of reflect.Value.Int on string Value
​
goroutine 1 [running]:
reflect.Value.Int(...)
    C:/Program Files/Go/src/reflect/value.go:1347
main.Test({0x8b5b20, 0xc00005a230})
    f:/goProject/src/dev_code/day23/example3/main/main.go:14 +0x297
main.main()
    f:/goProject/src/dev_code/day23/example3/main/main.go:19 +0x34
exit status 2
​
[Done] exited with code=1 in 0.589 seconds

3，value.set

设置变量值

reflect. value . SetFloat(),设置浮点数
reflect. value . SetInt(),设置整数
reflect value . SetString(),设置字符串

示例：报错

package main
​
import (
    "fmt"
    "reflect"
)
​
//定义函数传入
func Test(i interface{}) {
    v := reflect.ValueOf(i)
    //更新值
    v.SetInt(100)
    result := v.Int()
    fmt.Printf("更改后的类型是：%T,值是:%d\n", result, result)
​
}
func main() {
    var num int = 10
    Test(num) 
}
​
[Running] go run "f:\goProject\src\dev_code\day23\example4\main\main.go"
panic: reflect: reflect.Value.SetInt using unaddressable value
​
goroutine 1 [running]:
reflect.flag.mustBeAssignableSlow(0xc000028000)
    C:/Program Files/Go/src/reflect/value.go:262 +0x85
reflect.flag.mustBeAssignable(...)
    C:/Program Files/Go/src/reflect/value.go:249
reflect.Value.SetInt({0x795460, 0x837870, 0x100000000000000}, 0x64)
    C:/Program Files/Go/src/reflect/value.go:1991 +0x48
main.Test({0x795460, 0x837870})
    f:/goProject/src/dev_code/day23/example4/main/main.go:12 +0xc5
main.main()
    f:/goProject/src/dev_code/day23/example4/main/main.go:19 +0x2d
exit status 
​
[Done] exited with code=1 in 0.563 seconds

传入更改需要传指针，示例：

package main
​
import (
    "fmt"
    "reflect"
)
​
//定义函数传入
func Test(i interface{}) {
    v := reflect.ValueOf(i)
    //更新值需要value的地址，否则会崩溃Elem()表示*  传入指针
    v.Elem().SetInt(100)
    result := v.Elem().Int()
    fmt.Printf("更改后的类型是：%T,值是:%d\n", result, result)
​
}
func main() {
    var num int = 10
    Test(&num)//传入地址
}
[Running] go run "f:\goProject\src\dev_code\day23\example4\main\main.go"
更改后的类型是：int64,值是:100
​
[Done] exited with code=0 in 0.588 seconds

4，结构体的反射

示例:反射出结构体属性和方法数量。注意：方法名需要大写，相当于跨包调用

package main
​
import (
    "fmt"
    "reflect"
)
​
//结构体反射
type student struct {
    name  string
    age   int
    score float32
}
​
//结构体方法
func (s student) Run() { //方法名需要大写，反射相当于跨包调用
    fmt.Println("正在跑步")
}
func (s student) Sleep() {
    fmt.Println("正在睡觉")
}
​
//定义函数使用反射查看结构体字段数量和方法数量
func Test(i interface{}) {
    v := reflect.ValueOf(i)
    //类别判断
    if v.Kind() != reflect.Struct {
        fmt.Println("this is not struct")
        return
    }
    //获取结构体字段数量
    stu_num := v.NumField()
    fmt.Println("字段数量是：", stu_num)
    //获取结构体方法数量
    stu_methom := v.NumMethod()
    fmt.Println("方法数量是：", stu_methom)
​
}
func main() {
    var stu student = student{
        name:  "zhangsan",
        age:   20,
        score: 50,
    }
    Test(stu)
}
[Running] go run "f:\goProject\src\dev_code\day23\example5\main\main.go"
字段数量是： 3
方法数量是： 2
​
[Done] exited with code=0 in 0.592 seconds

获取字段属性值

package main
​
import (
    "fmt"
    "reflect"
)
​
type student struct {
    name string
    age  int
}
​
//反射来获取结构体中定义的属性值和类型
func Testprint(i interface{}) {
    v := reflect.ValueOf(i)
    //遍历结构体中所有的属性
    for i := 0; i < v.NumField(); i++ {
        fmt.Printf("索引：%d，值：%v,类型：%v\n", i, v.Field(i), v.Field(i).Kind())
    }
}
func main() {
    //实例化
    var stu student
    stu.name = "zhangsan"
    stu.age = 25
    Testprint(stu)
}
[Running] go run "f:\goProject\src\dev_code\day23\example9\main\main.go"
索引：0，值：zhangsan,类型：string
索引：1，值：25,类型：int
​
[Done] exited with code=0 in 0.593 seconds
也可以在cmd命令行中输出
F:\goProject\src\dev_code\day23\example9\main>go run main.go
索引：0，值：zhangsan,类型：string
索引：1，值：25,类型：int

更改属性的值

package main
​
import (
    "fmt"
    "reflect"
)
​
type student struct {
    Name string   //字段名字首字母需要大写
    Age  int
}
​
//更新值
func SetValue(i interface{}, name string) {
    v := reflect.ValueOf(i)
    vk := v.Kind()
    //如果不是指针，而指针指向的类型是结构体，则异常退出
    if vk != reflect.Ptr && v.Elem().Kind() == reflect.Struct {
        fmt.Println("type err")
        return
    }
    //修改值
    v.Elem().Field(0).SetString(name)
    //遍历结构体重所有的属性
    for i := 0; i < v.Elem().NumField(); i++ {
        fmt.Printf("索引：%d，值：%v，类型：%v\n", i, v.Elem().Field(i), v.Elem().Field(i).Kind())
    }
​
}
func main() {
    //实例化
    var stu student
    stu.Name = "zhangsan"
    stu.Age = 25
    //Testprint(stu)
    SetValue(&stu, "lisi")
}
​
[Running] go run "f:\goProject\src\dev_code\day23\example9\main\main.go"
索引：0，值：lisi，类型：string
索引：1，值：25，类型：int
​
[Done] exited with code=0 in 0.576 seconds

反射获取原信息

package main
​
import (
    "encoding/json"
    "fmt"
    "reflect"
)
​
type student struct {
    Name string `json:"name"`
    age  int
}
​
//反射来获取结构体中定义的属性值和类型
func Testprint(i interface{}) {
    v := reflect.ValueOf(i)
    //遍历结构体中所有的属性
    for i := 0; i < v.NumField(); i++ {
        fmt.Printf("索引：%d，值：%v,类型：%v\n", i, v.Field(i), v.Field(i).Kind())
    }
}
func main() {
    //实例化
    var stu student
    stu.Name = "zhangsan"
    stu.age = 25
    Testprint(stu)
    fmt.Println("-----原信息------")
    result, _ := json.Marshal(stu)
    fmt.Println("json原信息：", string(result))
    fmt.Println("-------反射获取原信息----------")
    //反射获取属性
    st := reflect.TypeOf(stu)
    s := st.Field(0)
    fmt.Printf("Name原信息名称：%s\n", s.Tag.Get("json"))
​
}
[Running] go run "f:\goProject\src\dev_code\day24\example1\main\main.go"
索引：0，值：zhangsan,类型：string
索引：1，值：25,类型：int
-----原信息------
json原信息： {"name":"zhangsan"}
-------反射获取原信息----------
Name原信息名称：name
​
[Done] exited with code=0 in 0.599 seconds

5，函数的反射

示例: Go中函数可以赋值给变量。

package main
​
import "fmt"
​
//定义函数
func hello() {
    fmt.Println("hello world")
}
​
func main() {
    a := hello
    a()
}
[Running] go run "f:\goProject\src\dev_code\day23\example6\main\main.go"
hello world
​
[Done] exited with code=0 in 0.583 seconds

示例:既然函数可以像普通的类型变量样， 那么在反射机制中就和不同的变量是一样， 在反射中函数和方法的类型(Type)都是reflect.Func,如果要调用函数，通过Value的Call()方法

package main
​
import (
    "fmt"
    "reflect"
)
​
//定义函数
func hello() {
    fmt.Println("hello world")
}
​
func main() {
    // a := hello
    // a()
    //反射使用函数
    v := reflect.ValueOf(hello)
    //类型判断是否是reflect.func
    if v.Kind() == reflect.Func {
        fmt.Println("函数")
    }
    //反射调用函数
    v.Call(nil)
​
}
[Running] go run "f:\goProject\src\dev_code\day23\example6\main\main.go"
函数
hello world
​
[Done] exited with code=0 in 0.605 seconds

示例：反射调用传参和返回值函数，传参传的是切片返回值也是切片

package main
​
import (
    "fmt"
    "reflect"
    "strconv"
)
​
//反射调用传参和返回值函数
func Test(i int) string {
    return strconv.Itoa(i)
}
​
func main() {
    v := reflect.ValueOf(Test)
    //定义参数切片
    params := make([]reflect.Value, 1)
    //切片元素赋值20
    params[0] = reflect.ValueOf(20)
    //反射调函数
    result := v.Call(params)
    fmt.Printf("result的类型：%T\n", result)
    //进行类型的转换切片转换string.[]reflect.Value转换成string
    s := result[0].Interface().(string)
    fmt.Printf("s的类型：%T,值：%s\n", s, s)
}
​
[Running] go run "f:\goProject\src\dev_code\day23\example7\main\main.go"
result的类型：[]reflect.Value
s的类型：string,值：20
​
[Done] exited with code=0 in 0.597 seconds

6，方法反射

反射中方法的调用。函数和方法可以说其实本质上是相同的，只不过方法与一个对象”进行了 “绑定"，方法是“对象”的一种行为，这种行为是对于这个对象”的一系列操作， 例如修改"对象的某个属性。 示例:

package main
​
import (
    "fmt"
    "reflect"
    "strconv"
)
​
//反射方法
type Student struct {
    Name string
    Age  int
}
​
//方法
func (s *Student) Setname(name string) {
    s.Name = name
}
func (s *Student) Setage(age int) {
    s.Age = age
}
func (s *Student) String() string {
    return fmt.Sprintf("%p", s) + " name:" + s.Name + " age:" + strconv.Itoa(s.Age)
}
func main() {
    //实例化检查student对象内容，用地址
    stu := &Student{"zhangsan", 25}
    //反射获取值：指针方式
    stuv := reflect.ValueOf(&stu).Elem()
    fmt.Println("修改前：", stuv.MethodByName("String").Call(nil)[0])
    //修改值
    p := make([]reflect.Value, 1)
    p[0] = reflect.ValueOf("lisi")
    //按名称来调用方法Setname
    stuv.MethodByName("Setname").Call(p)
    p[0] = reflect.ValueOf(35)
    stuv.MethodByName("Setage").Call(p)
    fmt.Println("修改后：", stuv.MethodByName("String").Call(nil)[0])
}
[Running] go run "f:\goProject\src\dev_code\day24\example2\main\main.go"
修改前： 0xc000004078 name:zhangsan age:25
修改后： 0xc000004078 name:lisi age:35
​
[Done] exited with code=0 in 0.62 seconds

反射中方法调用：按索引的方式调方法

PS：索引的排序是与方法名字的ASCII阿斯克码名字进行的排序与前后写方法的顺序无关

package main
​
import (
    "fmt"
    "reflect"
    "strconv"
)
​
//按索引的方式调用方法
//反射方法
type Student struct {
    Name string
    Age  int
}
​
//方法
func (s *Student) Setname(name string) {
    s.Name = name
}
func (s *Student) Setage(age int) {
    s.Age = age
}
func (s *Student) String() string {
    return fmt.Sprintf("%p", s) + " name:" + s.Name + " age:" + strconv.Itoa(s.Age)
}
func main() {
    //实例化检查student对象内容，用地址
    stu := &Student{"zhangsan", 25}
    //反射获取值：指针方式
    stuv := reflect.ValueOf(&stu).Elem()
    //反射获取值：值类型
    // stuv:=reflect.ValueOf(stu)
    //方式二，按方法的索引调用
    fmt.Println("修改前：", stuv.Method(2).Call(nil)[0])
    p := make([]reflect.Value, 1)
    p[0] = reflect.ValueOf("wangwu")
    stuv.Method(1).Call(p)
​
    p[0] = reflect.ValueOf(35)
    stuv.Method(0).Call(p)
    fmt.Println("修改后：", stuv.Method(2).Call(nil)[0])
}
​
//索引的排序是与方法名字的ASCII阿斯克码名字进行的排序与前后写方法的顺序无关
[Running] go run "f:\goProject\src\dev_code\day24\example3\main\main.go"
​

LiuHuan303
关注
Golang反射实现简易ORM框架实战
Golang编程笔记的博客
04-21 795
本文旨在通过Golang反射机制实现一个轻量级ORM框架，解决对象与关系型数据库（如MySQL）之间的映射问题。结构体到数据库表的元数据映射（表名、字段名、数据类型）基于反射的SQL语句动态生成（SELECT/INSERT/UPDATE/DELETE）数据库连接管理与事务处理基础实现典型CRUD操作的封装与实战应用目标框架需支持主流关系型数据库驱动（以MySQL为例），适配常见数据类型（字符串、整数、时间、布尔等），并提供类型安全的API接口。背景知识。
golang interface 与 反射
惜暮
02-01 3055
golang interface 与 反射golang interface 使用场景golang interface 数据结构golang interface 一些使用场景原理函数参数是 interface 的成本interface{}和带方法的interface的赋值过程动态类型与动态分发是如何实现的，动态分发什么时候进行，并且有什么样的调用成本如何进行类型转换如何进行断言，断言的成本有多高为什...
Go反射调用方法
用心做事
12-20 5254
Go提供了一个很重要的特性就是反射机制，反射机制对应处理一些特殊的应用场景非常实用。下文是Go反射调用函数的代码片段。func callReflect(any interface{}, name string, args... interface{}) []reflect.Value{ inputs := make([]reflect.Value, len(args)) for i,
搞懂go开发过程中反射处理结构体：属性修改、带参方法调用
nbplus_007的博客
10-18 728
通过反射，您可以在 Go 中有效地修改通过接口所引用的结构体的字段值。只需注意解包接口并确保实际结构体是可修改的。使用反射时，也要考虑性能和安全问题，因此仅在必要时使用。
golang反射调用方法
qq_29176323的博客
08-19 1743
golang通过reflect反射调用方法
Golang反射机制的实现分析——reflect.Type方法查找和调用
方亮的专栏
01-08 5407
在《Golang反射机制的实现分析——reflect.Type类型名称》一文中，我们分析了Golang获取类型基本信息的流程。本文将基于上述知识和经验，分析方法的查找和调用。（转载请指明出于breaksoftware的csdn博客） 方法 package main import ( "fmt" "reflect" ) type t20190107 struct { ...
go学习 --- 使用反射调用函数
qq_46093575的博客
02-12 1222
一、使用反射调用函数 package main import ( "fmt" "reflect" ) func Tom(i int) int { return i + 1 } func main() { //使用反射调用函数 v := reflect.ValueOf(Tom) fmt.Println("反射获取到的函数为:",v) //调用函数 call := v.Call([]reflect.Value{reflect.ValueOf(2)}) fmt.Println("调用函
Go语言从入门到精通四——反射
Dev-L的博客
02-16 316
反射 反射：可以在运行时动态获取变量的相关信息，需要导入reflect包。 import (&amp;amp;quot;reflect&amp;amp;quot;) 用法： reflect.TypeOf，获取变量的类型，返回reflect.Type类型 reflect.ValueOf，获取变量的值，返回reflect.Value类型 reflect.Value.Kind，获取变量的类别，返回一个常量 reflect.Value.Interfac...
Go 学习笔记——雨痕
11-28
Go语言，又称Golang，是一种静态类型的编程语言，由Google开发，于2007年首次对外公布，并在2009年进行了开源。Go语言的设计哲学是简洁、快速和安全。它支持垃圾回收，具有类型系统和一些并发控制机制。 变量的定义...
【Go高级编程】接口、反射与性能优化实战指南：深入解析与最佳实践应用
最新发布
05-16
内容概要：本文深入探讨了Go语言高级应用场景中的三大核心技术——接口设计、反射机制和性能优化。首先介绍了接口的定义与实现、空接口与类型断言、接口嵌套等内容，并通过具体代码示例展示了接口的实际应用。接着...
golang--reflect 通过反射调用方法
yh13750507646na的博客
07-12 1732
一、反射获得方法名 package main import ( "fmt" "reflect" "runtime" ) func main() { pFunc := reflect.ValueOf(OperateFunc).Pointer() funcName := runtime.FuncForPC(pFunc).Name() fmt.Println("方法名为:", fun...
golang反射(三)：反射调用对象的方法，调用动态方法
猛犸象
01-14 5119
通过反射访问一个对象的方法，要确保此方法是可导出的，否则会报错。 对象类型 type Dog struct { } func (t Dog) T1(nums []int) { fmt.Println(nums) fmt.Println("t1") } func (t Dog) T2() { fmt.Println("t2") } 列出对象的方法 var tt Dog getType := reflect.TypeOf(tt) for i:= 0; i<getType.NumMet.
Go学习(二十七):反射学习使用
weixin_39001207的博客
02-14 369
1.介绍 Go语言实现了反射，所谓反射就是动态运行时的状态。我们一般用到的包是reflect包，reflect 实现了运行时的反射能力，能够让程序操作不同类型的对象。反射包中有两对非常重要的函数和类型，两个函数分别是： 方法名 描述 reflect.TypeOf 可以获得任意值的类型对象,返回类型:reflect.Type reflect.ValueOf 可以获得任意值的值对象,返回类型:reflect.Value 反射包中的所有方法基本都是围绕着 reflect.Type 和 r
GO 快速学会使用反射
jiohfgj的博客
10-11 432
GO 快速学会使用反射 1. 介绍 在反射的世界里，我们拥有了获取一个对象的类型，属性及方法的能力。 在 Go 反射的世界里，有两种类型非常重要，是整个反射的核心，在学习 reflect 包的使用时，先得学习下这两种类型： reflect.Type reflect.Value 2. 方法示例 2.1 通过反射获取对象的键（类型）和值 package main import ( "fmt" "reflect" ) // func reflectNum(arg interface{}) {
golang之reflect
all_about_WZY的博客
06-08 487
Golang的Reflect包是一个强大而灵活的工具，可以帮助我们在运行时处理类型信息、调用函数和方法，以及修改变量的值。Golang的Reflect包（reflect）是一个强大的内置包，它提供了在运行时进行程序反射的功能。通过使用Reflect包，我们可以在不了解类型的情况下，动态地检查变量的类型、调用函数和方法，以及修改变量的值。使用Reflect包，我们可以在运行时检查一个变量的类型。方法获取变量的具体值。
GO反射（reflect）
小柏ぁ的博客
04-25 2148
目录 reflect 获取变量类别 ValueOf Value.Set 结构体反射 反射获取结构体中的属性值和类型 更改结构体属性值 反射实现Tag原信息 函数反射 Value的Call()方法 方法反射 reflect 1. reflect.TypeOf，获取变量的类型，返回reflect.Type类型 2...
Go笔记-反射
weixin_34319640的博客
02-28 189
2019独角兽企业重金招聘Python工程师标准>>> ...
go学习之异常记录01：panic: reflect: call of reflect.Value.NumField on int Value
lintiyan的博客
04-29 8767
代码： package main import ( "fmt" "reflect" "strconv" "strings" ) type Inner struct { Email string `validate:"email"` } type Outer struct { Age int `validate:"eq=15"` Inner Inner } func val...
解决panic: reflect: call of reflect.Value.Elem on struct Value [recovered]
空山新雨后，天气晚来秋
06-15 1947
解决panic: reflect: call of reflect.Value.Elem on struct Value [recovered]
Go语言反射深入解析：三大定律与接口关系
"Go语言反射三定律详解" ...Go语言的反射机制提供了一种强大的工具，用于在运行时检查和操作类型，但应当明智地使用，以保持代码的清晰性和效率。在理解和应用反射时，理解类型、接口以及它们之间的关系至关重要。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值