广告

扫码关注官方微信

扫码下载APP
返回顶部
首页 > 资讯 > 后端开发 > GO >Go语言学习之反射的用法详解
  • 524

0
分享到

Go语言学习之反射的用法详解

2024-04-02 19:04:59 524人浏览 安东尼
摘要

目录1. reflect 包1.1 获取变量类型1.2 断言处理类型转换2. ValueOf2.1 获取变量值2.2 类型转换3. Value.Set3.1 设置变量值3.2 示例4

反射指的是运行时动态的获取变量的相关信息

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

到此这篇关于Go语言学习之反射的用法详解的文章就介绍到这了,更多相关Go语言反射内容请搜索编程网以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程网！

您可能感兴趣的文档:
点击免费下载>>软考高级考试备考技巧/历年真题/备考精华资料

--结束END--

本文标题: Go语言学习之反射的用法详解

本文链接: https://www.lsjlt.com/news/146784.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com    QQ/279061341

本篇文章演示代码以及资料文档资料下载

下载Word文档到电脑，方便收藏和打印～

下载Word文档
去做题
猜你喜欢
  • Go语言学习之反射的用法详解
    目录1. reflect 包1.1 获取变量类型1.2 断言处理类型转换2. ValueOf2.1 获取变量值2.2 类型转换3. Value.Set3.1 设置变量值3.2 示例4...
    99+
    2022-11-13
  • Go语言学习教程之反射的示例详解
    目录介绍反射的规律1. 从接口值到反射对象的反射2. 从反射对象到接口值的反射3. 要修改反射对象，该值一定是可设置的介绍 reflect包实现运行时反射，允许一个程序操作任何类型...
    99+
    2022-11-11
  • Go语言学习之映射(map)的用法详解
    目录1. 什么是 map2. 创建 map3. 访问 map4. nil map和空map5. map中元素的返回值6. len()和delete()7. 测试map中元素...
    99+
    2022-11-13
  • Go语言学习之WaitGroup用法详解
    目录前言小试牛刀总览底层实现结构体AddDoneWait易错点总结前言 在前面的文章中，我们使用过 WaitGroup 进行任务编排，Go语言中的 ...
    99+
    2022-06-11
    GO 学习 go语言
  • Java高级语法学习之反射详解
    目录一、什么是反射二、准备测试：实体类的创建三、反射中的几个重要类及方法（一）反射中的重要类之Class（二）反射中的重要类之Field（三）反射中的重要类之Constructor（...
    99+
    2022-11-13
  • Go语言学习之指针的用法详解
    目录引言一、定义结构体1. 语法格式2. 示例二、访问结构体成员三、结构体作为函数参数四、结构体指针总结引言 Go 语言中数组可以存储同一类型的数据，但在结构体中我们可以为不同项定义...
    99+
    2022-11-13
  • Go语言学习之context包的用法详解
    目录前言需求一需求二Context 接口emptyCtxvalueCtx类型定义WithValuecancelCtx类型定义cancelCtxWithCanceltimerCtx类型...
    99+
    2022-11-11
  • Go语言学习之数组的用法详解
    目录引言一、数组的定义1. 语法2. 示例二、数组的初始化1. 未初始化的数组2. 使用初始化列表3. 省略数组长度4. 指定索引值的方式来初始化5. 访问数组元素6. 根据数组长度...
    99+
    2022-11-13
  • Go语言学习之new函数的用法详解
    目录1、new函数介绍2、示例3、总结1、new函数介绍 在 Go 语言中，new 函数用于动态地分配内存，返回一个指向新分配的零值的指针。它的语法如下： func new(Type...
    99+
    2023-05-20
    Go new函数用法 Go new函数 Go new
  • Golang学习之反射机制的用法详解
    目录介绍TypeOf() ValueOf()获取接口变量信息事先知道原有类型的时候事先不知道原有类型的时候介绍 反射的本质就是在程序运行的时候，获取对象的类型信息和内存结构，反射是把...
    99+
    2022-11-13
  • Go语言学习之链表的使用详解
    目录1. 什么是链表2. 单项链表的基本操作3. 使用 struct 定义单链表4. 尾部添加节点5. 头部插入节点6. 指定节点后添加新节点7. 删除节点1. 什么是链表 链表是一...
    99+
    2022-11-13
  • Go语言的反射机制详解
    反射是语言里面是非常重要的一个特性，我们经常会看见这个词，但是对于反射没有一个很好的理解，主要是因为对于反射的使用场景不太熟悉。 一、理解变量的内在机制 1.类型信息，元信息，是预先...
    99+
    2022-11-13
  • Go语言学习之条件语句使用详解
    目录1、if...else判断语法2、if嵌套语法3、switch语句4、类型switch语句5、fallthrough关键字使用小结1、if...else判断语法 语法的使用和其他...
    99+
    2022-11-13
  • Go语言学习之循环语句使用详解
    目录1、for循环2、for-each语法3、break的使用4、continue的使用5、goto的使用1、for循环 写法基本和其他语言一致，只是没有了while循环，用for代...
    99+
    2022-11-13
  • Go语言学习之文件操作方法详解
    目录引言1. 打开和关闭文件2. 读取文件2.1 defer 语句2.2 手动宕机处理2.3 打开文件并获取内容2.4 bufio 读取文件2.5 ioutil 读取文件2.6 读取...
    99+
    2022-11-13
  • Go语言学习之运算符使用详解
    目录1、算术运算符2、关系运算符3、逻辑运算符4、位运算符5、赋值运算符6、特殊运算符1、算术运算符 很常规，和java一样。 样例代码如下 // 算术运算符 func base()...
    99+
    2022-11-13
  • Go语言基础学习之Context的使用详解
    目录前言基本用法Context控制goroutine的生命周期使用 WithValue() 传递数据使用 WithCancel() 取消操作使用 WithDeadline() 设置截...
    99+
    2023-05-19
    Go语言Context使用 Go语言Context用法 Go Context
  • Go语言基础学习之指针详解
    目录1. 什么是指针2. 指针地址 & 指针类型3. 指针取值4. 空指针5. make6. new7. make 和 new 的区别8. 问题今天来说说 Go 语言基础中的...
    99+
    2022-12-30
    Go语言指针使用 Go语言指针 Go 指针
  • Go语言学习之结构体和方法使用详解
    目录1. 结构体别名定义2. 工厂模式3. Tag 原信息4. 匿名字段5. 方法1. 结构体别名定义 变量别名定义 package main import "fmt" type...
    99+
    2022-11-13
  • Go语言学习之时间函数使用详解
    目录引言1. 时间格式化2. 示例引言 1946年2月14日，人类历史上公认的第一台现代电子计算机“埃尼阿克”（ENIAC）诞生。 计算机语言时间戳是以197...
    99+
    2022-11-13
软考高级职称资格查询
软考职称历年真题下载
软考职称资料下载
热门wiki
近期文章
推荐阅读
热门问答
热门标签
编程网，编程工程师的家园，是目前国内优秀的开源技术社区之一，形成了由开源软件库、代码分享、资讯、协作翻译、讨论区和博客等几大频道内容，为IT开发者提供了一个发现、使用、并交流开源技术的平台。

  • 官方手机版

  • 微信公众号

  • 商务合作