Go语言学习之反射的用法详解
作者:隐姓埋名4869 发布时间:2023-06-16 06:40:40
反射指的是运行时动态的获取变量的相关信息
1. reflect 包
类型是变量,类别是常量
reflect.TypeOf,获取变量的类型,返回reflect.Type类型
reflect.ValueOf,获取变量的值,返回reflect.Value类型
reflect.Value.Kind,获取变量的类别,返回一个常量
reflect.Value.Interface(),转换成interface{}类型
1.1 获取变量类型
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() {
a := "hello"
Test(a)
}
输出结果如下
类型是 string
值是 hello
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)
//判断值的类别
c := v.Kind()
fmt.Println("类别是", c)
}
func main() {
var stu Student = Student{
Name: "张三",
Age: 18,
Score: 80,
}
Test(stu)
fmt.Println("-------------")
var num int = 10
Test(num)
}
输出结果如下
类型是 main.Student
类别是 struct
-------------
类型是 int
类别是 int
1.2 断言处理类型转换
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)
c := v.Kind()
fmt.Println("类别是", c)
fmt.Printf("c的类型是%T\n", c)
fmt.Printf("v的类型是%T\n", v)
//转换成接口
iv := v.Interface()
fmt.Printf("iv的类型%T\n", iv)
//断言处理
stu_iv, err := iv.(Student)
if err {
fmt.Printf("stu_iv的类型%T\n", stu_iv)
}
}
func main() {
var stu Student = Student{
Name: "张三",
Age: 18,
Score: 80,
}
Test(stu)
}
输出结果如下
类型是 main.Student
类别是 struct
c的类型是reflect.Kind
v的类型是reflect.Value
iv的类型main.Student
stu_iv的类型main.Student
2. ValueOf
2.1 获取变量值
reflect.valueof(x).Float()
reflect.valueof(x).Int()
reflect.valueof(x).String()
reflect.Valueof(x).Bool()
2.2 类型转换
package main
import (
"fmt"
"reflect"
)
func Test(i interface{}) {
v := reflect.ValueOf(i)
fmt.Printf("v的类型是%T\n", v)
//转换成指定类型
t := v.Int()
fmt.Printf("t的类型是%T\n", t)
}
func main() {
//类型不同的话会报错
var num int = 100
Test(num)
}
输出结果如下
v的类型是reflect.Value
t的类型是int64
3. Value.Set
3.1 设置变量值
reflect.Value.SetFloat(),设置浮点数
reflect.value.SetInt(),设置整数
reflect.Value.SetString(),设置字符串
3.2 示例
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("result类型为 %T, 值为 %d\n", result, result)
}
func main() {
var num int = 10
Test(&num)
}
输出结果如下
result类型为 int64, 值为 100
4. 结构体反射
反射出结构体的属性和方法数量
方法名需大写,需要被跨包调用识别
4.1 查看结构体字段数量和方法数量
package main
import (
"fmt"
"reflect"
)
//结构体
type Student struct {
Name string
Age int
Score float32
}
//结构体方法
func (s Student) Run() {
fmt.Println("Running")
}
func (s Student) Sleep() {
fmt.Println("Sleeping")
}
//使用反射查看结构体字段数量和方法数量
func Test(i interface{}) {
v := reflect.ValueOf(i)
//类别判断
if v.Kind() != reflect.Struct {
fmt.Println("不是结构体")
return
}
//获取结构体中字段数量
stu_num := v.NumField()
fmt.Println("字段数量: ", stu_num)
//获取结构体中方法数量
stu_meth := v.NumMethod()
fmt.Println("方法数量: ", stu_meth)
}
func main() {
var stu Student = Student{
Name: "张三",
Age: 18,
Score: 88,
}
Test(stu)
}
输出结果如下
字段数量: 3
方法数量: 2
4.2 获取结构体属性
package main
import (
"fmt"
"reflect"
)
type Student struct {
Name string
Age int
Score float32
}
func Test(i interface{}) {
v := reflect.ValueOf(i)
//获取结构体中每个属性
for i := 0; i < v.NumField(); i++ {
//输出属性值
fmt.Printf("%d %v\n", i, v.Field(i))
//输出属性值的类型
fmt.Printf("%d %v\n", i, v.Field(i).Kind())
}
}
func main() {
var stu Student = Student{
Name: "张三",
Age: 18,
Score: 88,
}
Test(stu)
}
输出结果如下
0 张三
0 string
1 18
1 int
2 88
2 float32
4.3 更改属性值
package main
import (
"fmt"
"reflect"
)
type Student struct {
Name string
Age int
Score float32
}
func Test(i interface{}, name string) {
v := reflect.ValueOf(i)
vk := v.Kind()
//判断是都为指针并指向结构体类型
if vk != reflect.Ptr && v.Elem().Kind() == reflect.Struct {
fmt.Println("expect struct")
return
}
//更改属性值
v.Elem().Field(0).SetString(name)
//获取结构体中每个属性
for i := 0; i < v.Elem().NumField(); i++ {
//输出属性值
fmt.Printf("%d %v\n", i, v.Elem().Field(i))
//输出属性值的类型
fmt.Printf("%d %v\n", i, v.Elem().Field(i).Kind())
}
}
func main() {
var stu Student = Student{
Name: "张三",
Age: 18,
Score: 88,
}
Test(&stu, "李四")
}
输出结果如下
0 李四
0 string
1 18
1 int
2 88
2 float32
4.4 Tag原信息处理
package main
import (
"encoding/json"
"fmt"
"reflect"
)
type Student struct {
Name string `json:"stu_name"`
Age int
Score float32
}
func Test(i interface{}, name string) {
v := reflect.ValueOf(i)
vk := v.Kind()
//判断是都为指针并指向结构体类型
if vk != reflect.Ptr && v.Elem().Kind() == reflect.Struct {
fmt.Println("expect struct")
return
}
//更改属性值
v.Elem().Field(0).SetString(name)
//获取结构体中每个属性
for i := 0; i < v.Elem().NumField(); i++ {
//输出属性值
fmt.Printf("%d %v\n", i, v.Elem().Field(i))
//输出属性值的类型
fmt.Printf("%d %v\n", i, v.Elem().Field(i).Kind())
}
}
func main() {
var stu Student = Student{
Name: "张三",
Age: 18,
Score: 88,
}
Test(&stu, "李四")
fmt.Println("----------------json原信息----------------")
result, _ := json.Marshal(stu)
fmt.Println("json原信息: ", string(result))
//反射获取类型
st := reflect.TypeOf(stu)
s := st.Field(0)
fmt.Printf("Name原信息名称: %s\n", s.Tag.Get("json"))
}
输出结果如下
0 李四
0 string
1 18
1 int
2 88
2 float32
----------------json原信息----------------
json原信息: {"stu_name":"李四","Age":18,"Score":88}
Name原信息名称: stu_name
5. 函数反射
Go 中函数是可以赋值给变量的
示例:
既然函数可以像普通的类型变量一样,那么在反射机制中就和不同的变量是一样的,在反射中函数和方法的类型(Type)都是reflect.Func
,如果要调用函数,通过 Value
的Call()
方法
package main
import (
"fmt"
"reflect"
)
func hello() {
fmt.Println("hello world")
}
func main() {
//反射使用函数
v := reflect.ValueOf(hello)
//类型判断是否属于reflect.func类型
if v.Kind() == reflect.Func {
fmt.Println("函数")
}
//反射调用函数
v.Call(nil) //Call中需要传入的是切片
}
输出结果如下
函数
hello world
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)
//切片元素赋值
params[0] = reflect.ValueOf(20)
//反射调函数
result := v.Call(params)
fmt.Printf("result的类型是 %T\n", result)
//[]reflect.Value切片转换string
s := result[0].Interface().(string)
fmt.Printf("s的类型是 %T ,值为 %s\n", s, s)
}
输出结果如下
result的类型是 []reflect.Value
s的类型是 string ,值为 20
6. 方法反射
反射中方法的调用,函数和方法可以说其实本质上是相同的,只不过方法与一个“对象”进行了“绑定”,方法是“对象”的一种行为,这种行为是对于这个“对象”的一系列操作,例如修改“对象”的某个属性
6.1 使用 MethodByName 名称调用方法
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() {
//实例化
stu := &Student{"张三", 19}
//反射获取值:指针方式
stuV := reflect.ValueOf(&stu).Elem()
fmt.Println("修改前: ", stuV.MethodByName("String").Call(nil)[0])
//修改值
params := make([]reflect.Value, 1)//定义切片
params[0] = reflect.ValueOf("李四")
stuV.MethodByName("SetName").Call(params)
params[0] = reflect.ValueOf(20)
stuV.MethodByName("SetAge").Call(params)
fmt.Println("修改后: ", stuV.MethodByName("String").Call(nil)[0])
}
输出结果如下
修改前: 0xc000004078,Name:张三,Age:19
修改后: 0xc000004078,Name:李四,Age:20
6.2 使用 method 索引调用方法
package main
import (
"fmt"
"reflect"
"strconv"
)
//反射方法
type Student struct {
Name string
Age int
}
//结构体方法
func (s *Student) B(name string) {
s.Name = name
}
func (s *Student) A(age int) {
s.Age = age
}
func (s *Student) C() string {
return fmt.Sprintf("%p", s) + ",Name:" + s.Name + ",Age:" + strconv.Itoa(s.Age)
}
func main() {
//实例化
stu := &Student{"张三", 19}
//反射获取值:指针方式
stuV := reflect.ValueOf(&stu).Elem()
//索引调用方法
fmt.Println("修改前: ", stuV.Method(2).Call(nil)[0])
params := make([]reflect.Value, 1)
params[0] = reflect.ValueOf("李四")
stuV.Method(1).Call(params)
params[0] = reflect.ValueOf(20)
stuV.Method(0).Call(params)
fmt.Println("修改后: ", stuV.Method(2).Call(nil)[0])
//调用索引大小取决于方法名称的ASCII大小进行排序
}
输出结果如下
修改前: 0xc000004078,Name:张三,Age:19
修改后: 0xc000004078,Name:李四,Age:20
来源:https://www.cnblogs.com/lvrui/p/16159478.html
![](https://www.aspxhome.com/images/zang.png)
![](https://www.aspxhome.com/images/jiucuo.png)
猜你喜欢
- MongoDB是由C++语言编写的非关系型数据库,是一个基于分布式文件存储的开源数据库系统,其内容存储形式类似JSON对象,它的字段值可以包
- 本文实例讲述了Python lambda表达式用法。分享给大家供大家参考,具体如下:lambda表达式,通常是在需要一个函数,但是又不想费神
- 先来看一个例子:>>> def foo(*args, **kwargs): print
- 我就废话不多说了,大家还是直接看代码吧~lt=client.fangjia.district_stat_all_0416dl = dt.fi
- 1) 首先安装docker:# 用 yum 安装并启动yum install docker -y && systemctl
- 创建SQL存储过程需要使用到的语法- 创建存储过程CREATE 存储过程的名称(参数)BEGIN...需要执行的SQL语句END- 调用CA
- 在没给大家讲解实现代码之前,先给大家分享效果图:之前别人都是用jq写的,自己整理了一下开始使用<el-form-item label=
- tensorlfow网络模型可视化。baidu了一些方法,现在介绍下我的流程和遇到的问题:配置window7tensorlfow1.5ana
- PHP PDO 预处理语句与存储过程很多更成熟的数据库都支持预处理语句的概念。什么是预处理语句?可以把它看作是想要运行的 SQL 的一种编译
- 现状≠将来?程序员做设计本身就很悲哀,纠结于客户与坚持之间就更是如此。无论我今后的路会怎么走,我想始终不变的事情就是与客户博弈了。无论是放弃
- 前言当我们运行测试函数时,我们希望确保测试函数在运行结束后,可以自己清理掉对环境的影响。这样的话,它们就不会干扰任何其他的测试函数,更不会日
- 1. 用qt designer编写主窗体,窗体类型是MainWindow,空白窗口上一个按钮。并转换成mainWindow.py# -*-
- 黑体是视觉设计师常用的一款字体,特别是针对广告的 Banner 等。根据 * 的相关介绍,有关黑体的定义可以认为:黑體与白体
- 今天整理之前做vue项目时遇到的一些问题,发现了当时遇到的一个很小但是又会引出很多问题的一个问题(总之就是很有意思,听我慢慢给你到来),这个
- 本文实例讲述了Python设计模式之工厂方法模式。分享给大家供大家参考,具体如下:工厂方法模式(Factory Method Pattern
- 视频地址我用20行代码,帮女神破解相册密码一、事情是这样的今早上班,公司女神小姐姐说,她去年去三亚旅游的照片打不开了好奇问了一下才知道。原来
- 一、背景先要从 InnoDB 的索引实现说起,InnoDB 有两大类索引:聚集索引 (clustered index)普通索引 (secon
- 可以任意转载,但转载时必须标明原作者charlee、原始链接http://tech.idv2.com/2006/11/23/javascri
- 本文以实例形式展示了Yii使用find findAll查找出指定字段的实现方法,分享给大家供大家参考之用。具体方法如下:总所周知,采用如下方
- 前言:今天要介绍这个神器,可以说是 pywebio 的 Plus + Pro&nbs