Go语言-反射

已于 2022-04-17 23:56:03 修改
阅读量378 收藏
点赞数
CC 4.0 BY-SA版权
文章标签： golang 开发语言 反射
于 2022-04-15 23:04:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_59439550/article/details/124204637

目录

前言

1、reflect

2、ValueOf

3、Value.Set

4、结构体反射

5、函数反射

6、方法反射

前言

概念：运动时动态的获取变量信息。

1、reflect

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

示例：获取变量类型。

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(p interface{}) {
	t := reflect.TypeOf(p)
	fmt.Println("类型：", t)
	//类别
	v := reflect.ValueOf(p)
	c := v.Kind()
	fmt.Println("类型：", c)
}
func main() {
	var stu Student = Student{
		Name:  "zhangsan",
		Age:   20,
		Score: 80,
	}
	Test(stu)
	fmt.Println("----------------")
	var num int = 10
	Test(num)
}

//运行结果为：
类型： main.Student
类型： struct
----------------
类型： int
类型： int

示例：断言处理类型转换。

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

获取变量值

reflect.valueof(x).Float()
reflect.valueof(x).Int()
reflect.valueof(x).String()
reflect.Valueof(x).Bool()

示例：类型转换。

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

设置变量值

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

示例：

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、结构体反射

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

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("不是结构体")
		return
	}
	//获取结构体中字段数量
	stu_num := v.NumField()
	fmt.Println("字段数量：", stu_num)
	//获取结构体中方法数量
	stu_meth := v.NumMethod()
	fmt.Println("方法数量：", stu_meth)
}
func main() {
	var stu Student = Student{
		Name:  "zhangsan",
		Age:   18,
		Score: 80,
	}
	Test(stu)
}

//运行结果为：
字段数量： 3
方法数量： 2

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

示例：获取结构体属性。

package main

import (
	"fmt"
	"reflect"
)

type Student struct {
	Name  string
	Age   int
	Score float32
}

//反射获取结构体中定义的属性值和类型
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 = Student{
		Name:  "zhangsan",
		Age:   20,
		Score: 80,
	}
	TestPrint(stu)
}

//运行结果为：
索引：0，值：zhangsan，类型：string
索引：1，值：20，类型：int
索引：2，值：80，类型：float32

示例：更改结构体属性值。

package main

import (
	"fmt"
	"reflect"
)

type Student struct {
	Name  string
	Age   int
	Score float32
}

//反射获取结构体中定义的属性值和类型
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 SetVaule(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 = Student{
		Name:  "zhangsan",
		Age:   20,
		Score: 80,
	}
	SetVaule(&stu, "lisi")
}

//运行结果为：
索引：0，值：lisi，类型：string
索引：1，值：20，类型：int
索引：2，值：80，类型：float32

示例：TAG原信息处理。

package main

import (
	"encoding/json"
	"fmt"
	"reflect"
)

type Student struct {
	Name  string `json:"stu_name"`
	Age   int
	Score float32
}

//反射获取结构体中定义的属性值和类型
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 = Student{
		Name:  "zhangsan",
		Age:   20,
		Score: 80,
	}
	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"))
}

//运行结果为：
索引：0，值：zhangsan，类型：string
索引：1，值：20，类型：int
索引：2，值：80，类型：float32
原信息---------------------
json原信息： {"stu_name":"zhangsan","Age":20,"Score":80}
反射获取原信息--------------
Name原信息名称：stu_name

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() {
	//实例化
	stu := &Student{"zhangsan", 19}
	//反射获取值：指针方式
	stuv := reflect.ValueOf(&stu).Elem()
	fmt.Println("修改前：", stuv.MethodByName("String").Call(nil)[0])

	//修改值
	params := make([]reflect.Value, 1)
	params[0] = reflect.ValueOf("lisi")
	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:zhangsan,Age:19
修改后： 0xc000004078,Name:lisi,Age:20

示例：

package main

//方式二：反射使用method
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{"zhangsan", 19}
	//反射获取值：指针方式
	stuv := reflect.ValueOf(&stu).Elem()
	//索引调用方法
	fmt.Println("修改前：", stuv.Method(2).Call(nil)[0])

	params := make([]reflect.Value, 1)
	params[0] = reflect.ValueOf(20)
	stuv.Method(0).Call(params)

	params[0] = reflect.ValueOf("lisi")
	stuv.Method(1).Call(params)
	fmt.Println("修改后：", stuv.Method(2).Call(nil)[0])
}

//运行结果为：
修改前： 0xc000004078,Name:zhangsanAge:19
修改后： 0xc000004078,Name:lisiAge:20
Zlwriii
关注
go语言基础 -- 反射
qq_42936727的博客
04-12 1030
反射可以在运行时动态获取变量的信息，如变量的类型（type），类别(kind)。如果是结构体变量，还可以获取到变量的字段、方法等结构体本身信息；通过反射，可以修改变量的值或调用关联的方法；使用反射需要import(“reflect”)我们前面的文章空接口接收任意类型的变量，通过typeof来判断变量类型。
go语言快速入门：go的反射机制(22)
热门推荐
知行合一 止于至善
02-16 1万+
Java的反射机制是其标志性的特征之一，正是这种语言本身支持的强大的机制使得很多流行的框架有了用武之地。C++中虽然也能实现，但是语言本身并没有提供标准的支持。 而作为一门现代的语言，go语言也引入了反射机制，在这篇文章中我们将会了解一下go语言中的反射机制是如何使用的。
Go语言_反射篇
weixin_33828101的博客
06-10 188
这里的GO使用的版本是1.2 Go语言的基本语法的使用已经在前几篇陆陆续续学完了，下面可能想写一些Go的标准库的使用了。 先是reflect库。 reflect库的godoc在http://golang.org/pkg/reflect/ Type和Value 首先，reflect包有两个数据类型我们必须知道，一个是Type，一个是Value。 Type就是定义的类型的一个数据类型，Va...
《Go语言圣经》反射概述
最新发布
woshihlf的博客
06-22 660
Go 语言的reflect包是实现反射机制的关键工具，它允许程序在运行时检查变量的类型、值和结构，突破了静态类型语言的限制，为动态编程提供了可能。和，分别用于处理类型信息和值信息。
Go语言基础之反射
weixin_30470643的博客
09-13 397
目录 一、变量的内在机制 二、反射介绍 三、reflect包 四、TypeOf 4.1 type name和type kind 五、ValueOf 5.1 通过反射获取值 5.2 通过反射设置变量的值 ...
Go语言 反射
qq_19018277的博客
04-05 501
说说 Go语言 的反射~
Go语言反射
js010111的博客
05-09 282
#反射reflect 一、引入 先看官方Doc中Rob Pike给出的关于反射的定义： Reflection in computing is the ability of a program to examine its own structure, particularly through types; it’s a form of metaprogramming. It’s also a great source of confusion. (在计算机领域，反射是一种让程序——主要是通过类型——理解其自
桫哥-GOlang基础-x1_Go语言面试题_第1辑
06-12
在本资源"桫哥-GOlang基础-x1_Go语言面试题_第1辑"中，我们可以探索Go语言的基础知识和面试中常见的问题。Go语言，又称为Golang，是Google开发的一种静态类型的、编译式的、并发型且具有垃圾回收功能的编程语言。它...
桫哥-GOlang-09反射
06-12
在本课程"桫哥-GOlang-09反射"中，我们将深入探讨Go语言的反射(reflection)机制，这是Go编程语言中一个非常强大的特性。反射允许程序在运行时检查和修改其自身的行为，这对于创建高度灵活和动态的软件系统来说至关...
谈谈Go语言的反射三定律
09-21
Go语言的反射机制是其强大的特性之一，它允许程序在运行时检查和修改自身的结构，特别是类型信息。本文将深入探讨Go语言中的反射三定律，以及类型和接口的基础知识。 首先，反射的核心在于程序能够检查并操作自身的...
桫哥-GOlang基础-Go语言实战：驾考系统
06-12
《Go语言实战：驾考系统》是一门针对Go语言初学者和进阶者的教程，旨在帮助学习者从零开始，逐步掌握Go语言的基础语法，并通过实战案例深化理解，提升编程能力。课程风格轻松活泼，注重理论与实践的结合，鼓励创新...
GO语言反射
aiduo4911的博客
05-28 167
反射可以作为了解，不必深入！ 反射介绍 Go语音提供了一种机制在运行时更新变量和检查它们的值、调用它们的方法和它们支持的内在操作，但是在编译时并不知道这些变量的具体类型。这种机制被称为反射。反射也可以让我们将类型本身作为第一类的值类型处理。 Go程序在运行期使用reflect包访问程序的反射信息。 reflect包 反射是由 reflect 包提供支持. 它定义了两个重要的类型,...
go语言反射
.
12-11 319
go语言反射 反射的类型对象（reflect.Type） 在Go程序中，使用reflect.TypeOf()函数可以获得任意值的类型对象（reflect.Type），程序通过类型对象可以访问任意值的类型信息。 反射的类型（Type）与种类（Kind） 在使用反射时，需要首先理解类型（Type）和种类（Kind）的区别。编程中，使用最多的是类型，但在反射中，当需要区分一个大品种的类型时，就会用到种类（Kind）。例如，需要统一判断类型中的指针时，使用种类（Kind）信息就较为方便。 Go程序中的类型（Type
Go语言的反射
DXB2021的博客
04-12 349
反射 方法和类型的反射 变量的最基本信息就是类型和值：反射包的Type用来表示一个Go语言类型，反射包的Value为Go值提供了反射接口。 代码如下： package main import ( "fmt" "reflect" ) func main() { var x float64 = 3.4 fmt.Println("type:", reflect.TypeOf(x)) v := reflect.ValueOf(x) fmt.Println("value:", v) fm.
Go语言之反射
zhghost的专栏
12-11 524
笔者原本是C++开发人员，之前对于反射没太大概念，学了GO之后，才开始接触，在研究了一段时间之后，有了些认识，便整理一个帖子，希望对大家有所帮助。 在学习反射的时候，笔者一直在问自己，反射是什么？为什么要用到反射？它是怎么实现的？笔者觉得，在知道这些问题的答案之后，才算是真正了解反射。下面笔者便从这些问题来着手整理反射。 一、反射是什么？ 维基百科上的定义： 在计算机科学中，反射是指计...
go语言之反射
小神仙的博客
01-04 325
反射 反射可以支持 不知道对象的类信息下访问类的方法和属性 再举个常见例子，我和你编写同一个动物园软件，分开写不同模块，你负责写饲养员部分，我负责写动物模块，我会传给你一个动物对象，你负责调教好它，我们事先完全解耦，写作过程中也完全没有沟通，我传给你一个黑盒子对象你只能自己用反射摸索，比如你查询我传给你的对象有哪些方法：你发现有一个“飞”方法，那你可能在养一只鸟，这时你可以调用这个方法让它飞一飞，...
深入理解Go语言反射机制及其实战应用
资源摘要信息:"桫哥-GOlang-09反射课程内容涵盖Go语言的反射机制，从基础语法到进阶应用，帮助学习者建立坚实的Go语言基础，并通过实战案例和框架封装的进阶学习，深入理解反射在Go语言中的应用。本课程采取生动活泼...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值