Golang 学习二十（反射）

最新推荐文章于 2024-04-28 05:41:13 发布
最新推荐文章于 2024-04-28 05:41:13 发布
阅读量509 收藏 2
点赞数
分类专栏： 云计算 golang devops 文章标签： golang 学习 开发语言
无
本文链接：https://blog.csdn.net/shenyuanhaojie/article/details/124286139
版权
云计算 同时被 3 个专栏收录
196 篇文章 26 订阅
订阅专栏
devops
26 篇文章 0 订阅
订阅专栏
golang
25 篇文章 4 订阅
订阅专栏

文章目录

变量 ---> 一个值，一个类型，值类型
数组 ---> 相同类型，多个值，长度固定，值类型
切片 ---> 相同类型，多个值，长度动态，引用类型，有序
指针 ---> 地址，引用类型
映射 ---> k-v 按名字取值，无序，相同类型，多个值，长度动态
结构体 ---> 多个值，类型多样，字段（属性）
接口 ---> 接受任意类型的定义

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

import ("reflect")

1. reflect

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

1650296396314

int ---> interface ---> reflect.value ---> string

示例：获取变量类型

package main

import (
    "fmt"
    "reflect"
)

func test(i interface{}) {
    // 反射获取值类型
    t := reflect.TypeOf(i)
    fmt.Println(t)
    // 反射获取值
    v := reflect.ValueOf(i)
    fmt.Println(v)
}

func main() {
    var a int = 10
    test(a)
}

/*
int
10
*/

示例：类型和类别

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)
    // 反射获取类别
    v := reflect.ValueOf(i)
    k := v.Kind()
    fmt.Println("类别：",k)
}

func main() {
    var stu Student = Student {
        Name: "zhangsan",
        Age: 19,
        Score: 88,
    }
    test(stu)
}

/*
类型： main.Student
类别： struct
*/

示例：断言处理类型转化

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)
    // 反射获取类别
    v := reflect.ValueOf(i)
    k := v.Kind()
    fmt.Println("类别：",k)
    
    // 转换成接口类型
    iv := v.Interface()
    // 断言
    stu,ok := iv.(Student)
    if ok {
        fmt.Printf("结构：%v 类型：%T\n",stu,stu)
    }
}

func main() {
    var stu Student = Student {
        Name: "zhangsan",
        Age: 19,
        Score: 88,
    }
    test(stu)
}

/*
类型： main.Student
类别： struct
结构：{zhangsan 19 88} 类型：main.Student
*/

2. ValueOf

获取变量值

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

示例:类型转换

package main

import (
    "fmt"
    "reflect"
)

func testInt(b interface{}) {
    val := reflect.ValueOf(b)
    fmt.Printf("val 类型：%T\n",val)
    // 转换成 int 类型，其他类型都可以转化成 string
    a := val.Int()
    fmt.Printf("a 类型：%T\n",a)
}

func main() {
    testInt(100)
}

/*
val 类型：reflect.Value
a 类型：int64
*/

3. Value.Set

设置变量值

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

示例：思考为何会报错

package main

import (
    "fmt"
    "reflect"
)

func testInt(b interface{}) {
    val := reflect.ValueOf(b)
    // 更改值
    val.SetInt(100)
    c := val.Int()
    fmt.Printf("类型：%T,值：%d\n",c,c)
}

func main() {
    var i = 10
    testInt(i)
    fmt.Println(i)
}

/*
panic: reflect: reflect.Value.SetInt using unaddressable value

goroutine 1 [running]:
......
*/

修改后

package main

import (
    "fmt"
    "reflect"
)

func testInt(b interface{}) {
    val := reflect.ValueOf(b)
    // 更改值需要value的地址，否则会崩溃，Elem() 表示 *
    val.Elem().SetInt(100)
    c := val.Elem().Int()
    fmt.Printf("类型：%T,值：%d\n",c,c)
}

func main() {
    var i = 10
    testInt(&i)
    fmt.Println(i)
}

/*
类型：int64,值：100
100
*/

4. 结构体反射

示例：反射出结构体属性和方法数量

package main

import (
    "fmt"
    "reflect"
)

type Student struct {
    Name string
    Age int
    Score float32
}

func (s Student) Sleep() {
    fmt.Println("正在睡觉")
}

func (s Student) Run(min interface{}) {
    fmt.Printf("跑步%d分钟",min)
}

// 断言结构体
func Test(object interface{}) {
    // 获取值
    v := reflect.ValueOf(object)
    // 获取类别
    c := v.Kind()
    // 判断类别是否为结构体
    if c != reflect.Struct {
        fmt.Println("expect struct")
        return
    }
    // 获取结构体字段数量
    num := v.NumField()
    fmt.Println("字段数量:",num)
    // 获取结构体方法数量
    numOfMethod := v.NumMethod()
    fmt.Println("方法数量:",numOfMethod)
}

func main() {
    var stu Student = Student {
        Name: "zhangsan",
        Age: 18,
        Score: 90,
    }
    Test(stu)
}

/*
字段数量: 3
方法数量: 2
*/

5. 函数反射

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

package main

import "fmt"

func Hello() {
    fmt.Println("hello world")
}

func main() {
    // 函数可以赋值给变量
    a := Hello
    a()
}

/*
hello world
*/

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

package main

import (
    "fmt"
    "reflect"
)

func Hello() {
    fmt.Println("hello world")
}

func main() {
    // 反射获取 hello
    v := reflect.ValueOf(Hello)
    fmt.Printf("类型:%T\n",v)
    // 判断 hello 的类型
    if v.Kind() == reflect.Func {
        fmt.Println("OK")
    }
    // 反射调用函数
    v.Call(nil)
}

/*
类型:reflect.Value
OK
hello world
*/

Value 的 Call() 方法的参数是一个 Value 的 slice，对应的反射函数类型的参数，返回值也是一个 Value 的 slice，同样对应反射函数类型的返回值。

package main

import (
    "fmt"
    "reflect"
    "strconv"
)

func prints(i int) string {
    fmt.Println("i=",i)
    return strconv.Itoa(i)
}

func main() {
    fv := reflect.ValueOf(prints)
    // 定义参数切片
    params := make([]reflect.Value,1)
    // 参数为 20
    params[0] = reflect.ValueOf(20)
    // 反射函数，获取处理结果
    result := fv.Call(params)
    fmt.Printf("result 类型:%T\n",result)
    fmt.Printf("result 转换后类型:%T,值是:%s\n",result[0].Interface().(string),result[0].Interface().(string))
}

/*
i= 20
result 类型:[]reflect.Value
result 转换后类型:string,值是:20
*/

6. 方法反射

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

package main

import (
    "fmt"
    "reflect"
    "strconv"
)

type Student struct {
    age int
    name string
}

func (s *Student) SetAge(i int) {
    s.age = i
}

func (s *Student) SetName(name string) {
    s.name = name
}

func (s *Student) String() string {
    return fmt.Sprintf("%p",s) + "--name:" + s.name + " age:" + strconv.Itoa(s.age)
}

func main() {
    // 实例化
    stu := &Student{22,"zhangsan"}
    // 反射获取值，指针方式
    stuV := reflect.ValueOf(&stu).Elem()
    // 也可以使用非指针（值类型） stuV := reflect.ValueOf(stu)
    fmt.Println("Before:",stuV.MethodByName("String").Call(nil)[0])
    
    // 修改值
    params := make([]reflect.Value,1)
    params[0] = reflect.ValueOf(18)
    stuV.MethodByName("SetAge").Call(params)
    
    params[0] = reflect.ValueOf("lisi")
    stuV.MethodByName("SetName").Call(params)
    
    fmt.Println("After:",stuV.MethodByName("String").Call(nil)[0])
}

/*
Before: 0xc000004078--name:zhangsan age:22
After: 0xc000004078--name:lisi age:18
*/

示例：使用 Method 方式

package main

import (
    "fmt"
    "reflect"
    "strconv"
)

type Student struct {
    age int
    name string
}

func (s *Student) SetAge(i int) {
    s.age = i
}

func (s *Student) SetName(name string) {
    s.name = name
}

func (s *Student) String() string {
    return fmt.Sprintf("%p",s) + "--name:" + s.name + " age:" + strconv.Itoa(s.age)
}

func main() {
    // 实例化
    stu := &Student{22,"zhangsan"}
    stuV := reflect.ValueOf(&stu).Elem()
    // 方式二
    fmt.Println("Before:",stuV.Method(2).Call(nil)[0])
    // 索引大小取决于方法名称的 ASCII 大小
    params := make([]reflect.Value,1)
    params[0] = reflect.ValueOf(18)
    stuV.Method(0).Call(params)
    params[0] = reflect.ValueOf("lisi")
    stuV.Method(1).Call(params)
    fmt.Println("After:",stuV.Method(2).Call(nil)[0])
}

/*
Before: 0xc000004078--name:zhangsan age:22
After: 0xc000004078--name:lisi age:18
*/
公博义
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
go reflect 与slice
offhours365的专栏
12-02 1495
1. slice slice底层存储的其实一个结构，如下： type slice struct { array unsafe.Pointer len int cap int } 先提供一篇文章加深理解slice对象的文章: https://segmentfault.com/a/1190000017910165?utm_source=sf-related 以下我用go1.13.8 linux/amd64，再次测试： func testsl
[Golang][reflect]SliceOf
sz66cm 学习随笔
11-18 459
SliceOf 函数体 func SliceOf(t Type) Type 第一次看完这里的案例还是没有看懂这个SliceOf是怎么用的; 自己动手 package main import( "fmt" "reflect" ) type CMS struct { name string age int } func main() { objs := []interface{}{ 1, 1.2, "abc",
有效解决IndexError: list index out of range异常的正确方法
最新发布
wbajsjhhhhh的博客
04-28 4438
有效解决IndexError: list index out of range异常的正确方法
Golang之Slice处理
fourierr的博客
12-11 866
func EqualSlice(slice1, slice2 interface{}) bool { if slice2 == nil || slice1 == nil { return false } if reflect.TypeOf(slice1).Kind() != reflect.TypeOf(slice2).Kind() || reflect.ValueOf(slice1).Index(0).Kind() != reflect.ValueOf(slice2).Index(0).Kin.
golang反射(二)：反射结构体切片读取数据
猛犸象
12-14 4538
type Man struct { Id int Name string } s1 := make([]Man, 0) s1 = append(s1, Man{1, "a"}) s1 = append(s1, Man{2, "b"}) s1 = append(s1, Man{3, "c"}) func(v interface{}) { getValue := reflect.ValueOf(v) // Value of v if getValue.Kind() != reflect.Slic
golang反射动态添加切片(数组)
LGF的专栏
05-05 6289
package main func main(){ var arr1 = []int{} a0 := reflect.ValueOf(&arr1).Elem() e0 := make([]reflect.Value, 0) e0 = append(e0, reflect.ValueOf(100)) e0 = append(e0, reflect.Va...
Go-轻松在golang中处理slice的库
08-14
轻松在golang中处理slice的库
详解Golang利用反射reflect动态调用方法
09-19
主要介绍了详解Golang利用反射reflect动态调用方法，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
golang的学习笔记
04-21
《Golang学习笔记》第四版，是一份深入探讨Go语言的宝贵资料，旨在帮助开发者全面理解和掌握这门现代、高效且简洁的后端开发语言。Go语言，又称Golang，由Google公司于2009年推出，由Robert Griesemer、Rob Pike及...
学习golang
03-23
在"学习golang"的主题中，我们将探讨Golang的入门知识、Web编程技巧以及如何通过相关书籍提升Go语言技能。 首先，让我们来看看"Golang入门"这一标签所涵盖的内容。Go语言的入门学习通常从安装和设置环境开始，包括...
Golang学习笔记（一）：简介
01-21
反射 语言交互性 高性能/高效开发 安装 安装说明 地址 http://golang.org/doc/install 包下载 地址 https://code.google.com/p/go/downloads/list 确认是否安装成功 代码如下: go version //查看版本 环境变量...
golang学习笔记资源
07-03
本资源集合是针对Golang的学习笔记，对于初学者和进阶者都是宝贵的资料。我们将深入探讨Golang的一些核心概念和技术。 首先，让我们了解Golang的基础。Go语言的设计目标是简洁、清晰和高效，它的语法简洁明了，易于...
反射 数据类型_利用 Go 反射机制实现判断 slice 中是否存在某个 item
weixin_42510243的博客
01-10 452
点击上方蓝色“Go语言中文网”关注我们，领全套Go资料，每天学习Go语言为什么需要？ 日常开发过程中经常遇到需要判断某个 slice(或者 array)中是否包含某个 item 的情况，比如判断 10 是否在[]int{1,2,3}中怎么做？ 一般最容易想到的方法是遍历 slice 中的每个元素，直到找到了该元素，否则返回 false，如下：packagemainfuncIsIn...
Golang Reflect反射的使用详解1
weixin_33950035的博客
01-29 1324
2019独角兽企业重金招聘Python工程师标准>>> ...
Golang 反射(Reflection)教程
neweastsun的专栏
02-07 1214
Golang反射是元编程主题，本文将尽量使其简化，让你轻松掌握并在合适场景中灵活应用。 从需求谈起 反射是一种编程能力，可以在运行时检查变量的类型和值。也许你还不理解这意思，读完本文你将会有清晰理解反射的概念。 那什么情况下需要在运行时获取变量的类型和值呢？假如有这样一个需求，写一个函数带有struct类型作为参数，函数功能是根据参数创建INSERT SQL语句保存数据。 type User struct { UserId int UserName string } 下面我们写插.
GO语言reflect反射篇
weixin_42629418的博客
06-06 398
1.1 reflect反射是什么，为什么需要反射 GO 反射的意义：Go 语言的 ORM 库离不开它，Go 语言的 json 序列化库离不开它， fmt包字符串格式化离不开它，Go 语言的运行时更是离不开它。 反射的目标： 获取变量的类型信息，例如这个类型的名称、占用字节数、所有的方法列表、所有的内部字段结构、它的底层存储类型等等。 动态的修改变量内部字段值。比如 json 的反序列化，你有的是对象内部字段的名称和相应的值，你需要把这些字段的值循环填充到对象相应的字段里。 1.2 reflect反射 ◼
Go 的反射包浅析
hKY0fB8kZ6xY
10-28 1430
本文主要介绍了 Go 的反射包中的常用类型和方法，并使用了几个例子进行了说明。
go总结： 反射+ Map和 Slice 的传递
wowenlong的博客
02-02 998
Go语言反射（reflection）简述
go语言切片Slice和数组Array对比panic: runtime error: index out of range问题解决
alike_u的博客
06-26 1540
目录前言一、go slice是什么二、go slice实战案例1.slice创建、使用2、slice的长度和容量概念理解3. 切片扩容及slice panic: runtime error: index out of range总结 在go语言的学习历程当中，slice数据类型引起了我的好奇心。为啥不直接使用Slice，是人性的扭曲还是道德的沦丧~，下面让我们一探究竟~~go语言中的slice是一个基于Array封装的数据结构，go语言中slice的使用频率远高于array，其身影频频出现在源码实现当中。s
golang 学习路线
06-10
好的，关于 golang 的学习路线，我可以提供以下建议： 1. 先了解 golang 的基本...7. 学习 golang 的高级编程，包括 golang 的反射、接口、垃圾回收机制等等。 以上是我推荐的 golang 学习路线，希望对你有所帮助。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值