Go语言之反射（反射的简单使用，原理）

于 2023-04-21 22:12:44 发布
阅读量654 收藏 1
点赞数
分类专栏： golang 文章标签： golang 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Sheena997/article/details/129710197
版权

一、反射的基础

1.什么是反射

  • Go语言中，反射的机制就是在运行的时候，可以获取到其变量的类型和值，且可以对其类型和值进行检查，对其值进行修改。
  • 即在不知道具体的类型的情况下，可以用反射机制来查看变量类型、更新变量的值。
  • Go中反射主要涉及到两个概念：Type和Value。对所有的接口进行反射时，都可以得到一个包含Type和Value的信息结构，Type是反射的这个变量本身的类型信息，Value是反射的这个变量本身的值信息。

2.反射的使用

(1) 获取到变量类型
  • 方法：reflect.TypeOf(x)
  • 作用：获取变量x的类型信息
    package main

import (
	"fmt"
	"reflect"
)

func main(){
	x := 3.1415
	y := 3
	z := "sheena"
	u := true

	fmt.Println("x的type为：", reflect.TypeOf(x))
	fmt.Println("y的type为：", reflect.TypeOf(y))
	fmt.Println("z的type为：", reflect.TypeOf(z))
	fmt.Println("u的type为：", reflect.TypeOf(u))
}
    结果：在这里插入图片描述
(2) 进行变量类型判断
  • 方法：xtype := reflect.TypeOf(x) xkind := xtype.Kind() if xkind == reflect.Type
  • 作用：先调用TypeOf方法获取到x的类型信息，再获取到类型信息中的类型，与类型进行判断
    package main

import (
	"fmt"
	"reflect"
)

func main(){
	x := 3.1415
	y := 3
	z := "sheena"
	u := true

	//获取变量的类型
	xtype := reflect.TypeOf(x)
	ytype := reflect.TypeOf(y)
	ztype := reflect.TypeOf(z)
	utype := reflect.TypeOf(u)

	//Kind()方法的返回结果主要是用来进行类型判断的
	xkind := xtype.Kind()
	ykind := ytype.Kind()
	zkind := ztype.Kind()
	ukind := utype.Kind()

	//对x进行类型判断
	if xkind == reflect.String{
		fmt.Println("x的type是string")
	}else if xkind == reflect.Float64{
		fmt.Println("x的type是float64")
	}

	//对y进行类型判断
	if ykind == reflect.Float64{
		fmt.Println("y的type是Float64")
	}else if ykind == reflect.Int{
		fmt.Println("y的type是int")
	}

	//对z进行类型判断
	if zkind == reflect.Float64{
		fmt.Println("z的type是Float64")
	}else if zkind == reflect.String{
		fmt.Println("z的type是string")
	}

	//对u进行类型判断
	if ukind == reflect.Bool{
		fmt.Println("u的type是bool")
	}else if ukind == reflect.String{
		fmt.Println("u的type是string")
	}
}
    结果：
    在这里插入图片描述
(3) 获取到变量值
  • 方法：reflect.ValueOf(x)
  • 作用：获取x变量的值
    package main

import (
	"fmt"
	"reflect"
)

func main(){
	x := 3.1415
	y := 3
	z := "sheena"
	u := true

	fmt.Println("x的value为：", reflect.ValueOf(x))
	fmt.Println("y的value为：", reflect.ValueOf(y))
	fmt.Println("z的value为：", reflect.ValueOf(z))
	fmt.Println("u的value为：", reflect.ValueOf(u))
}
    结果：
    在这里插入图片描述
(4) 修改变量值
  • 方法一：使用具体类型的值的设置方法，如SetString()、SetFloat64()等（可直接接收具体要修改的值）
    package main

import (
	"fmt"
	"reflect"
)

func main(){
	x := 3.1415
	y := 3
	z := "sheena"
	u := true

	fmt.Println("x修改前的value为：", reflect.ValueOf(x))
	fmt.Println("y修改前的value为：", reflect.ValueOf(y))
	fmt.Println("z修改前的value为：", reflect.ValueOf(z))
	fmt.Println("u修改前的value为：", reflect.ValueOf(u))

	//通过反射传入变量x的地址，并且通过Ele
	rex := reflect.ValueOf(&x).Elem()
	rey := reflect.ValueOf(&y).Elem()
	rez := reflect.ValueOf(&z).Elem()
	reu := reflect.ValueOf(&u).Elem()

	//判断是否可以修改变量x的值，若可以，则用SetFLoat64()方法进行修改
	if rex.CanSet(){
		rex.SetFloat(61.23466)
		fmt.Println("x修改后的value为：", reflect.ValueOf(x))
	}else {
		fmt.Println("该变量不能修改")
	}

	if rey.CanSet(){
		rey.SetInt(10000)
		fmt.Println("y修改后的value为：", reflect.ValueOf(y))
	}else {
		fmt.Println("该变量不能修改")
	}

	if rez.CanSet(){
		rez.SetString("hello world")
		fmt.Println("z修改后的value为：", reflect.ValueOf(z))
	}else{
		fmt.Println("该变量不能修改")
	}

	if reu.CanSet(){
		reu.SetBool(false)
		fmt.Println("u修改后的value为：", reflect.ValueOf(u))
	}else {
		fmt.Println("该变量不能修改")
	}
}
    结果：
    在这里插入图片描述
  • 方法二：是用Set方法直接设置值（注意set方法接收的是ValueOf的返回值）
    package main

import (
	"fmt"
	"reflect"
)

func main(){
	x := 3.1415
	y := 3
	z := "sheena"
	u := true

	fmt.Println("x修改前的value为：", reflect.ValueOf(x))
	fmt.Println("y修改前的value为：", reflect.ValueOf(y))
	fmt.Println("z修改前的value为：", reflect.ValueOf(z))
	fmt.Println("u修改前的value为：", reflect.ValueOf(u))

	//通过反射传入变量x的地址，并且通过Ele
	rex := reflect.ValueOf(&x).Elem()
	rey := reflect.ValueOf(&y).Elem()
	rez := reflect.ValueOf(&z).Elem()
	reu := reflect.ValueOf(&u).Elem()

	//判断是否可以修改变量x的值，若可以，则用Set()方法进行修改
	if rex.CanSet(){
		ax := reflect.ValueOf(61.23466) // 使用Set方法修改值，Set方法接收的是ValueOf的返回值
		rex.Set(ax)
		fmt.Println("x修改后的value为：", reflect.ValueOf(x))
	}else {
		fmt.Println("该变量不能修改")
	}

	if rey.CanSet(){
		ay := reflect.ValueOf(10000)// 使用Set方法修改值，Set方法接收的是ValueOf的返回值
		rey.Set(ay)
		fmt.Println("y修改后的value为：", reflect.ValueOf(y))
	}else {
		fmt.Println("该变量不能修改")
	}

	if rez.CanSet(){
		az := reflect.ValueOf("hello world")// 使用Set方法修改值，Set方法接收的是ValueOf的返回值
		rez.Set(az)
		fmt.Println("z修改后的value为：", reflect.ValueOf(z))
	}else{
		fmt.Println("该变量不能修改")
	}

	if reu.CanSet(){
		au := reflect.ValueOf(false)// 使用Set方法修改值，Set方法接收的是ValueOf的返回值
		reu.Set(au)
		fmt.Println("u修改后的value为：", reflect.ValueOf(u))
	}else {
		fmt.Println("该变量不能修改")
	}
}
    结果：
    在这里插入图片描述
(5) 获取变量的指针所指向的对象
  • 方法：Elem()方法
  • 作用：获取变量x的指针所指向的对象
    package main

import (
	"fmt"
	"reflect"
)

func main(){
	x := 3.1415
	y := 3
	z := "sheena"
	u := true

	//传入变量地址
	px := reflect.ValueOf(&x)
	py := reflect.ValueOf(&y)
	pz := reflect.ValueOf(&z)
	pu := reflect.ValueOf(&u)

	fmt.Println("x的地址是", px)
	fmt.Println("y的地址是", py)
	fmt.Println("z的地址是", pz)
	fmt.Println("u的地址是", pu)

	//通过变量地址获取到变量的值
	xe := px.Elem()
	ye := py.Elem()
	ze := pz.Elem()
	ue := pu.Elem()
	
	fmt.Println("x的值是", xe)
	fmt.Println("y的值是", ye)
	fmt.Println("z的值是", ze)
	fmt.Println("u的值是", ue)
}
    结果：
    在这里插入图片描述
(6) 获取结构体变量的类型和值
package main

import (
	"fmt"
	"reflect"
)

type Stu struct{
	Name string
	Age int
	Sex string
	IsCan bool
}

func main(){
	s1 := Stu{Name: "王一", Age: 18, Sex: "男", IsCan: false}
	s2 := Stu{Name: "王二", Age: 19, Sex: "女", IsCan: true}
	s3 := Stu{Name: "张三", Age: 20, Sex: "男", IsCan: false}

	//反射获取结构体的类型和值
	fmt.Println("s1的类型", reflect.TypeOf(s1))
	fmt.Println("s1的值", reflect.ValueOf(s1))

	fmt.Println("s2的类型", reflect.TypeOf(s2))
	fmt.Println("s2的值", reflect.ValueOf(s2))

	fmt.Println("s3的类型", reflect.TypeOf(s3))
	fmt.Println("s3的值", reflect.ValueOf(s3))


	fmt.Println("TypeOf()和Kind()方法输出的区别")
	fmt.Println("TypeOf(s1)：", reflect.TypeOf(s1))
	s1tp := reflect.TypeOf(s1)
	fmt.Println("Kind(s1)：", s1tp.Kind())
}

结果：
在这里插入图片描述

二、反射的原理

1.反射如何获取类型信息

  • reflect包中提供TypeOf接口用于获取一个变量的类型信息。它接收一个空接口类型的参数，并返回一个reflect.Type类型的返回值
  • TypeOf接口：
    func TypeOf(i interface{}) Type{
	eface := *(*emptyInterface)(unsafe.Pointer(&i))
	return toType(eface.type)
}

//Type接口提供了一系列方法
type Type interface{
	Align()  int                      //对齐边界
	FieldAlign()  int
	Method(int) Method
	MethodByName(string)  (Method, bool)       //方法
	NumMethod()  int         //类型名称
	Name()  string
	PkgPath()  string         //包路径
	Slize()  uintptr
	String()  string
	Kind()  Kind
	Implements(u Type)  bool         //是否实现指定接口
	AssginableTo(u Type)  bool
	ConvertibleTo(u Type)  bool
	Comparable()  bool                //是否可比较
}
    在这里插入图片描述

2.反射如何修改变量值

  • 用反射修改变量值，需要用到reflect.Value类型了，如下所示结构体，有三个元素，type字段存储反射变量的类型元数据指针；ptr字段存储数据地址；flag字段是一个位标识符，存储反射变量的描述信息，例如是否为指针，是否为方法或是否只读等等。
    type Value struct {
      type *rtype
      ptr unsafe.Pointer
      flag
}

func ValueOf(i interface{}) Value{
      if i == nill{
           return Value()
      }
      escapes(i)
      return unpackEface(i)
}
  • 通常会有reflect.ValueOf方法来拿到反射类型的值，注意这里的参数i和TypeOf函数一样是个空接口类型，所以处理方式一样。（编译阶段会增加一个临时变量作为拷贝）
    在这里插入图片描述
Sheena爽
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
golang接口类型与反射底层原理深度解析
weixin_44545838的博客
06-18 1431
反射是Go语言中的一种高级特性，它可以在程序运行时动态地获取和修改变量的类型和值，从而实现很多有用的功能，本博客首先介绍接口类型，为介绍反射打基础，然后从反射的三大法则、底层原理和性能三个方面来介绍Go语言的反射。
Go语言中反射包的实现原理（The Laws of Reflection)
kjfcpua的专栏
01-04 2980
前言 过去只是知道某些语言带有反射，但是一直没机会使用这种高级功能，所以也没有深入了解过。昨天看golang时里面提到reflection，既然这么多语言支持这个性质，那就深入了解下好了。这篇文档翻译自官方文档的The Laws of Reflection，翻译目的不是为了翻译，而是加深自己记忆以及理解，所以有些地方可能不会直译，因为我没那么高水平，有时自己能看懂，但是按着原话翻译出来给别人
GO语言reflect反射原理浅析
A0AA0aaa的博客
05-12 445
GO语言reflect反射原理浅析
Go语言（三）反射机制
weixin_30572613的博客
07-13 159
1 package main 2 3 import( 4 "fmt" 5 "reflect" 6 ) 7 8 func main(){ 9 // iterate through the attributes of a Data Model instance 10 for name, mtype := range attributes(...
go中的反射
白小白的小白的博客
08-30 1674
go 反射
图文详解go语言反射实现原理
12-20
本文将深入探讨Go语言反射的实现原理，尤其是与`interface`和`unsafe.Pointer`的关系。 首先，我们需要了解`interface`的基础知识。在Go语言中，`interface`是一种类型定义，它定义了一组方法签名。`interface`分为...
Go语言中反射的正确使用
09-21
本文将深入探讨Go语言反射的正确使用及其注意事项。 首先，我们要明白反射的概念。反射是一种元编程技术，使代码能够获取和操作其自身的类型信息。在Go中，这通常通过`reflect`包来实现。反射的主要功能是允许程序...
谈谈Go语言的反射三定律
09-21
Go语言的反射机制是其强大的特性之一，它允许程序在运行时检查和修改自身的结构，特别是类型信息。本文将深入探讨Go语言中的反射三定律，以及类型和接口的基础知识。 首先，反射的核心在于程序能够检查并操作自身的...
Go-dig一个用于Go语言基于反射的依赖注入工具包
08-14
Go-dig是一个强大的依赖注入工具包，专门为Go语言设计，利用了Go的反射(reflection)特性，使得在构建复杂的应用程序时，可以更加方便地管理对象间的依赖关系。依赖注入是一种设计模式，它有助于提高代码的可测试性、...
go语言反射机制、reflect.TypeOf、 reflect.ValueOf、字符串处理（详解）
一个非常Cool的人
01-13 4275
爆肝1w字详解Go语言反射机制的用法,还有一些字符串处理方法,以及配置文件解析项目的实现。对于Go语言初学者会有很大的帮助。这里会找到你所遇到问题的答案。
深入理解go语言反射机制，看这一篇就够了
sunmaoxiang的博客
11-19 3045
golang的反射机制 在计算机学中，反射式编程（英语：reflective programming）或反射（英语：reflection），是指计算机程序(runtime）可以访问、检测和修改它本身状态或行为的一种能力。用比喻来说，反射就是程序在运行的时候能够“观察”并且修改自己的行为。 一、go语言的类型系统以及接口 ​ 在go语言中，反射是在类型系统中构建的，类型包括系统内自带的底层类型和自定义类型比方说： type MyInt int var i int var j MyInt 上述代码中i是系
Go语言--反射(reflect)
yunfan
11-24 1802
0 反射的概念 反射是指计算机程序在运行时（runtime）可以访问、检测和修改本身状态或行为的一种能力。通俗地将，反射就是程序能够在运行时动态地查看自己的状态，并且允许修改自身的行为。 ...
深度解密Go语言之反射
woliuqiangdong的博客
10-26 644
在开始正文前，和大家说点题外话。 上一篇关于 Interface 的文章发出后，获得了很多的关注和阅读。比如，登上了 GoCN 的每日新闻第一条： 可能是编辑者觉得这篇文章称不上“深度解密”，把标题给小小地改动了下，哈哈~~ 在博客园登上了 48 小时阅读排行榜： 在开发者头条 APP （类似于今日头条，不过内容都是技术相关的，还挺有意思的）上收获了 150 收藏，并被推荐到首页最显眼的 banner 位置，阅读量达到了 1w 多，只是不知道这个数字是否是真实的，有点难.
12_Go语言 反射详解
热门推荐
数据知道的博客
07-08 3万+
1. 反射定义： 可以在运行时动态获取变量的相关信息。 Import (“reflect”) 官方对此有个非常简明的介绍，两句话耐人寻味： 反射提供一种让程序检查自身结构的能力。再精确点的描述是“反射是一种检查interface变量的底层类型和值的机制”； 反射是困惑的源泉；（想深入了解反射，必须深入理解类型和接口概念。） 2. 方法: reflect.TypeOf，获取变量的类型，返回re...
大量实例详解Go反射机制原理与应用
tyler_download的专栏
01-19 868
大量代码示例帮你轻松掌握烧脑的GO反射机制
golang的interface与反射实现原理
hust_joker的博客
05-06 1608
1、什么是interface ​ interface通过定义一系列的方法集合指定了其他类型的行为。对于一个类型，当且仅当它实现了某一个interface方法集的所有方法，我们称这个类型满足了这个interface。可以理解为interface是一个抽象的类型，这个类型定义了一系列的方法，当某个其他类型完全实现了该interface的所有的方法，可以称这个类型是当前抽象interface的一个实例。可以把interface理解为一个合约，方法即是合同细节，当其他类型满足了所有细节（方法），即可认为该类型满足了
go语言中反射机理详解
qq_30505673的博客
08-11 3656
package main import ( “fmt” “reflect” ) type User struct { Id int Name string Age int } type Manager struct { User //反射会将匿名字段作为一个独立字段来处理 Title string } fu...
go语言快速入门：go的反射机制(22)
知行合一 止于至善
02-16 1万+
Java的反射机制是其标志性的特征之一，正是这种语言本身支持的强大的机制使得很多流行的框架有了用武之地。C++中虽然也能实现，但是语言本身并没有提供标准的支持。 而作为一门现代的语言，go语言也引入了反射机制，在这篇文章中我们将会了解一下go语言中的反射机制是如何使用的。
go反射机制
zengchen73的专栏
07-07 1269
1. 反射定律反射可以将“接口类型变量”转换为“反射类型对象”。反射可以将“反射类型对象”转换为“接口类型变量”。如果要修改“反射类型对象”，其值必须是“可写的”。a. “接口类型变量”=>“反射类型对象”所谓的反射类型，就是reflect.Type和reflect.Value var a int = 30 v := reflect.ValueOf(a) //返回Value类型对象，值...
golang 反射原理
最新发布
06-10
Go语言的反射机制是指程序可以在运行时检查自身的结构和类型信息，并且可以根据这些信息进行操作的能力。 在Go语言中，反射由reflect包实现。它提供了两个重要的类型：Type和Value，分别用于表示类型和值。Type表示...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值