go语言：反射

最新推荐文章于 2023-11-28 20:20:46 发布
最新推荐文章于 2023-11-28 20:20:46 发布
阅读量353 收藏 1
点赞数
分类专栏： go 文章标签： golang 反射
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41775886/article/details/112767361
版权

go语言：反射

1. 反射的应用

1.1 反射简介

  • go语言通过reflect包提供运行时反射机制
  • 静态类型interface{}、Type类型、Value类型

1.2 反射应用场景

  1. go语言API库封装。 Fmt.Printf
  2. go框架开发。
  3. 结构体标签的实现。

1.3 反射的基本使用

  1. 在运行时，动态的获取变量信息。值、类型、类别

  2. 在运行时，获取结构体的信息。字段名、方法

  3. 在运行时，修改变量指，调用方法。

2. 反射的原理

变量 – reflect.TypeOf() – reflect.Type 类型 – interface{kind() Field() NumField() … }

变量 – reflect.ValueOf() – reflect.Value 类型 – interface{kind() Type() Elem() Field() NumField() … }

在这里插入图片描述

3. 反射的实际编程使用

  • 变量 —— 空接口传参 —— interface —— reflect.ValueOf() —— reflect.Value类型 —— Interface() 方法—— interface —— 类型断言 —— 变量
  • 变量、interface 、reflect.Value类型 可以相互转换。

在这里插入图片描述

3.1 基础数据类型的类型转换

func reflectForint(i interface{}) {
	// 获取reflect.Value 类型
	reVal := reflect.ValueOf(i)

	// n := reVal + 100    // 不能使用value类型与int类型运算
	// fmt.Printf("%T, %v\n", reVal, reVal)

	// reflect.Value 类型 -- interface{}
	iVal := reVal.Interface()
	fmt.Printf("%T, %v\n", iVal, iVal)

	// n := iVal + 10     // 不能使用interface类型与int类型运算
	// 解决办法：使用类型断言将interface转换成int
	val := iVal.(int)
	n := val + 10
	fmt.Println(n)
}

func main() {
	// 定义基础类型变量
	var num int = 10

	// 变量 --> interface{}
	reflectForint(num)
}

3.2 结构体类型的转换

type Student struct {
	Name string
	Id int
	Addr string
}

func ReflectForStruct(i interface{}) {
	// interface -> reflect.Value
	reVal := reflect.ValueOf(i)
	reType := reflect.TypeOf(i)
	fmt.Printf("type=%v, val=%v\n", reType, reVal)

	// reflect.Value --> interface{}
	iVal := reVal.Interface()

	// 类型断言 interface{} --> struct
	// 只能用下面的val来索引成员
	if val, ok := iVal.(Student); ok {
		fmt.Printf("val=%v, iVal=%v, reVal=%v, val.Name=%v\n",
			val, iVal, reVal, val.Name)
	}
}

func main() {
	stu := Student{"alin", 2017002297, "北京"}
	// 从变量 --> interface{}
	ReflectForStruct(stu)
}

3.3 不使用类型断言进行类型转换

使用reflect.Kind()函数

func (v Value) Kind() Kind

const (
    Invalid Kind = iota
    Bool
    Int
    Int8
    Int16
    Int32
    Int64
    Uint
    Uint8
    Uint16
    Uint32
    Uint64
    Uintptr
    Float32
    Float64
    Complex64
    Complex128
    Array
    Chan
    Func
    Interface
    Map
    Ptr
    Slice
    String
    Struct
    UnsafePointer
)

func reflectTest(i interface{}) {
	// 获取reflect.Value
	reVal := reflect.ValueOf(i)

	if reVal.Kind() == reflect.Int {
		n := reVal.Int() + 100
		fmt.Println("判断是一个int, n=", n)
	}
	if reVal.Kind() == reflect.Bool {
		fmt.Println("判断是一个bool, ", reVal.Bool())
	}
	if reVal.Kind() == reflect.Float64 {
		fmt.Println("判断是一个Float64, ", reVal.Float())
	}
	if reVal.Kind() == reflect.String {
		fmt.Println("判断是一个String, ", reVal.String()+"haha")
	}
}

func main() {
	var a int = 10
	var f float64 = 3.12
	var str string = "hoho"
	var bl bool = true

	reflectTest(a)
	reflectTest(f)
	reflectTest(str)
	reflectTest(bl)
}

3.4 kind和type区别

  • kind：类别。较type而言更大的范畴，更官方的范畴。

  • type：（不是reflect.Type，是数据类型）具体类型。较kind而言表示的范畴更具体

type Student4 struct {
	Name string
	Id int
	Addr string
}

func reflectForKind(i interface{}) {
	fmt.Printf("%T\n", i)
	reVal := reflect.ValueOf(i)
	fmt.Printf("%v\n", reVal.Kind())
}

func main() {
	// var num int = 10
	var stu Student4
	reflectForKind(stu)
}

输出结果：
main.Student4
struct

3.5 反射修改变量值

  1. 传参时需要传递地址值（引用）。 eg:reflectForSetInt(&num)
  2. 使用reflect.Value 类型的 SetXxx() 方法修改对应类型值。
  3. 必须借助 reflect.Value.Elem()来获取Value类型对应的变量的封装。有点像"解引用"。
func reflectForSetInt(iptr interface{}) {
	// 获取变量对应的reflect.Value
	reVal := reflect.ValueOf(iptr)

	fmt.Println("kind1:", reVal.Kind())
	// fmt.Printf("%T\n", iptr)
	fmt.Println("kind2:", reVal.Elem().Kind())

	if reVal.Kind() == reflect.Ptr && reVal.Elem().Kind() == reflect.Int {
		reVal.Elem().SetInt(666)
	}
}

func main() {
	var num int = 10
	reflectForSetInt(&num)
	fmt.Println("num=", num)
}

4. 反射操作结构体

  1. 定义带Tag的结构体类型

  2. 初始化结构体test := {xxx, xxx, ...}

  3. 获取reflect.Type类型和reflect.Value类型

  4. 循环获取结构体字段的信息

    1. 获取字段个数，使用NumField()方法

    2. 循环获取每一个字段的信息。 – StructField

      type StructField struct {
   // Name是字段的名字。PkgPath是非导出字段的包路径，对导出字段该字段为""。
   // 参见http://golang.org/ref/spec#Uniqueness_of_identifiers
   Name    string
   PkgPath string
   Type      Type      // 字段的类型
   Tag       StructTag // 字段的标签
   Offset    uintptr   // 字段在结构体中的字节偏移量
   Index     []int     // 用于Type.FieldByIndex时的索引切片
   Anonymous bool      // 是否匿名字段
}

      type StructTag string

func (tag StructTag) Get(key string) string
// 传入key值，获取tag的value

    3. 获取字段名 structField.Name

    4. 获取字段类型 structField.Type

    5. 获取字段值 reVal.Field(i)

const tagName = "Testing"

type Test struct {
	Name string `Testing:"-"`    // 序列化结果中没有这个属性
	Age int `Testing:"age,omitempty"`
	Id int `Testing:"idx,string"`
	Sex string `Testing:"sex"`
}

func main() {
	test := Test{"AAA", 18, 1001, "male"}

	reType := reflect.TypeOf(test)

	reVal := reflect.ValueOf(test)

	for i:=0; i<reType.NumField(); i++ {
		// 获取每一个字段的结构体描述信息StructField
		StructField := reType.Field(i)
		// 获取tag的值
		tagVal := StructField.Tag.Get(tagName)

		fmt.Printf("%d. %v(%v):%v, TAG:`%v`\n",
			i + 1, StructField.Name, StructField.Type, reVal.Field(i), tagVal)
	}
}
// 输出结果
1. Name(string):AAA, TAG:`-`
2. Age(int):18, TAG:`age,omitempty`
3. Id(int):1001, TAG:`idx,string`
4. Sex(string):male, TAG:`sex`

5. 反射使用欧冠结构体Tag

  1. 创建结构体
  2. 初始化对象 test, 传参(&test)
  3. 封装实现函数
  4. 获取reflect.Type，借助kind判断是否传参为ptr，进一步判断是否为struct
  5. 获取reflect.Value类型，使用Elem()方法得到Value对象reVal
  6. for 获取字段，以NumField()为循环上限
  7. 处理输出的标签名
    1. 获取结构体字段信息structField := reVal.Type().Field()
    2. 有tag标签
      1. 获取structField成员 – StructTag
      2. 根据已知的tag的key(“label”)，获取对应的tag的value值。 Get()方法
    3. 没有tag标签的
      1. 判断Get()方法的返回值，如果为""
      2. 使用字段名，拼接标签名。structField.Name+":"
  8. 处理输入的数据值
    1. 取出字段的数据值保存成字符串。 Sprintf()/reVal.Field(i)
    2. 判断字段类型为string进一步处理if structField.Type.Kind() == reflect.String
    3. 进一步判断类型为string的字段的tag的key为"uppercase"的value是否为"true"
    4. 根据判断结果，使用stings.Toupper()、string.ToLower()
  9. 拼接标签名、数据值输出
type Person struct {
	Name        string `label:"Person Name: " uppercase:"true"`
	Age         int    `label:"Age is: "`
	Sex         string `label:"Sex is: "`
	Description string
}

func myMarshal(iptr interface{}) {
	// 获取Type
	reType := reflect.TypeOf(iptr)
	// 容错
	if reType.Kind() != reflect.Ptr || reType.Elem().Kind() != reflect.Struct {
		fmt.Println("输入的数据非指针类型")
		return
	}

	// 获取value
	reVal := reflect.ValueOf(iptr).Elem()

	// 获取字段信息及对应值
	for i:=0; i<reVal.NumField(); i++ {
		// fmt.Println(reVal.Field(i))
		// 获取字段信息 StructField
		structField := reVal.Type().Field(i)
		// 获取Tag成员
		tag := structField.Tag
		// 获取tag 中key对应的value值
		tagValue := tag.Get("label")
		// 判断如果tagValue为空，使用字段名作为tagValue
		if tagValue == "" {
			tagValue = structField.Name + ":"
		}
		// fmt.Println(tagValue)

		// 获取字段的数据值
		dataVal := fmt.Sprintf("%v", reVal.Field(i))
		// fmt.Println(dataVal)
		// 判断是否是string
		if structField.Type.Kind() == reflect.String {
			// 进一步判断是否tag中的uppercase的值为true
			if tag.Get("uppercase") == "true" {
				// 将对应的数据值转大写
				dataVal = strings.ToUpper(dataVal)
			} else {
				dataVal = strings.ToLower(dataVal)
			}
		}

		// 拼接输出
		fmt.Println(tagValue+dataVal)
	}
}

func main() {
	person := Person{"alin", 21, "Male", "COOL"}
	myMarshal(&person)
}
// 输出结果
Person Name: ALIN
Age is: 21
Sex is: male
Description:cool

6. 反射调用结构体方法

  1. 获取方法的个数
func (v Value) NumMethod() int
  1. 指定方法。参数从0开始计数。方法名：按ASCII码排序
func (v Value) Method(i int) Value
  1. 调用Method指定的方法。
func (v Value) Call(in []Value) []Value
  • 参数：传递给要调用的那个方法的参数
  • 返回值：要调用的方法的返回值。通过方法的下标(从0开始)指定。
type Student2 struct {
	Id int 		`json:"index"`
	Name string `json:"name"`
	Age int 	`json:"学员年龄"`
	Score float32
}

func (stu Student2) Print() {
	fmt.Println("------------stu:", stu)
}

// 注意：方法名，首字母必须大写。否则 reflect.Value 的 Method 找不到该方法。
func (stu Student2) Zdd(a, b int) int {
	return a + b
}

func (stu Student2) ResetInfo(id int, name string, age int, score float32) {
	stu.Id = id
	stu.Name = name
	stu.Age = age
	stu.Score = score
}

func useReflect(ref interface{})  {
	reType := reflect.TypeOf(ref)
	reVal := reflect.ValueOf(ref)

	reKind := reVal.Kind()
	if reKind != reflect.Struct {
		fmt.Println("Kind err!")
		return
	}
	numField := reVal.NumField()
	fmt.Println("Student 结构体包含字段数为：", numField)

	for i:=0; i<numField; i++{
		tagVal := reType.Field(i).Tag.Get("json")

		if tagVal != "" {
			fmt.Printf("%d. %v (%v) : %v, Tag : '%v'\n",
				i+1, reType.Field(i).Name, reType.Field(i).Type, reVal.Field(i), tagVal)
		} else {
			fmt.Printf("%d. %v (%v) : %v\n",
				i+1, reType.Field(i).Name, reType.Field(i).Type, reVal.Field(i))
		}
	}
	numMethod := reVal.NumMethod()
	fmt.Printf("Student 结构体含有 %d 个方法。\n", numMethod)

	// 调用一个方法 --- print
	reVal.Method(0).Call(nil)

	var params []reflect.Value
	params = append(params, reflect.ValueOf(123))
	params = append(params, reflect.ValueOf(543))

	// 调用一个方法  --- Add
	sum := reVal.Method(2).Call(params)
	fmt.Println("sum =", sum[0].Int())
}

func main() {
	stu := Student2{9527, "Andy", 18, 90.5}

	useReflect(stu)
}
alin Wang
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
go那些事儿|go反射使用第一弹(TypeOf)
qq_41066066的博客
01-10 814
文章始发于公众号【迈莫coding】 地址：https://mp.weixin.qq.com/s/F8yZyqC5UwoewsX0THqy1w 即将用Go语言从零到一编写ORM框架，目前先把所用技术讲一遍，大家可以尽情期待，可以关注【迈莫coding】，了解最新状况。 目录 反射概念 reflect包 反射类型(Type)和种类(Kind) 反射类型(Type)使用 反射类型对象(TypeOf)使用 结构体对象 变量 常量 指针 反射获取结构体的成员类型 介绍structField结构 演.
go reflect TypeOf 与ValueOf
Andes Home 千年的塔 -十年技术，风雨兼程
01-02 7393
学习go的反射对于理解go的底层实现以及接口机制有着非常重要的价值；本篇文章从一个源程序来体验一下go反射的两个核心函数TypeOf 和ValueOf的使用方法，特别体验下怎么根据type构造type实例的办法。 package main import ( "fmt" "reflect" ) type Speaker interface { Speak()string
谈谈Go语言的反射三定律
09-21
本文中，我们将解释Go语言中反射的运作机制。每个编程语言的反射模型不大相同，很多语言索性就不支持反射（C、C++）。由于本文是介绍Go语言的，所以当我们谈到“反射”时，默认为是Go语言中的反射。
Golang 反射机制 reflect.TypeOf、 reflect.ValueOf、字符串处理
wgchen
02-25 1667
Golang 反射机制 reflect.TypeOf、 reflect.ValueOf、字符串处理
Go typeof、 Kind、Elem、Name用法
刘洋的博客
03-21 1301
GO typeof 用法 type Hello struct { Name string } func useTypeOf(val interface{}) { msgType := reflect.TypeOf(val) msgKind := msgType.Kind() msgID := msgType.Elem() msgIDname := msgType.Elem().Name() fmt.Println("Type is ", msgType) fmt.Println("
golang reflect
weixin_33730836的博客
10-05 234
reflect包实现了运行时反射，允许程序操作任意类型的对象。典...
golang面试题：reflect（反射包）如何获取字段tag​？为什么json包不能导出私有变量的tag？
最新发布
ldxxxxll的博客
11-28 599
json包里使用的时候，会结构体里的字段边上加tag，有没有什么办法可以获取到这个tag的内容呢？
图文详解go语言反射实现原理
12-20
如果对golang的 interface 底层实现还没有理解，可以去看我之前的文章： Go语言interface底层实现 ， unsafe.Pointer 会在后续的文章中做介绍。 （本文目前使用的Go环境是Go 1.12.9） interface回顾 首先我们简单的...
Go语言中反射的正确使用
12-31
不同语言的反射模型实现不一样，本文中的反射，仅仅指的是Go语言中的反射模型。 反射有两个问题，在使用前需要三思： 大量的使用反射会损失一定性能 Clear is better than clever. Reflection is never clear. Go...
Go语言中使用反射的方法
12-25
本文实例讲述了Go语言中使用反射的方法。分享给大家供大家参考。具体实现方法如下： 代码如下:// Data Model type Dish struct {  Id int  Name string  Origin string  Query func() } 创建实例如下： 代码...
与ChatGpt聊天，学习golang标签的反射机制
程序空间
02-17 1794
与ChatGpt聊天，学习golang标签的反射机制引ChatGPT火了以后，本拐先是恐惧，之后是拥抱。最近很多编程知识的学习，都是通过 chatgpt来搞定。众所周知，本拐就是一个啥技术都半斤八两的程序员，这次，为了学习golang中一些反射的机制，主要是tag属性，本拐又与chatgpt来了一次深入交流。过程本拐确实对golang中的tag属性所知甚少，所以先从json开始吧，挖个坑先。问g...
Go语言反射详解
技术宅拯救世界
05-27 578
这里写目录标题exm 1exm 2exm 3exm 4exm 5exm 6exm 7exm 6.5 exm 1 package main import ( "fmt" "reflect" ) // reflect demo func reflectType(x interface{}) { // 我不知道别人调用我这个函数的时候会传进来什么类型的变量 // 1. 方法1：通过类型断言 // 2. 方法2：借助反射 obj := reflect.TypeOf(x) fmt.Println(
Go语言——反射
脑袋装水的博客
01-23 725
文章目录一、reflect-反射-浅析-重要Go语言中的类型反射第一定律：反射可以将“接口类型变量”转换为“反射类型对象”反射第二定律：反射可以将“反射类型对象”转换为“接口类型变量”反射第三定律：如果要修改“反射类型对象”其值必须是“可写的”结构体总结二、reflect-反射类型对象-获取类型信息1. TypeOf()和reflect.Type类型1.1 理解反射的类型（Type）与种类（Kind）1.1.1 反射种类（Kind）的定义1.1.2 从类型对象中获取类型名称和种类的例子1.2. refle
反射创建对象_Go 反射：根据类型创建对象-第一部分（原始类型）
weixin_39606137的博客
12-01 606
这是关于在 Go 中根据类型创建对象的博客系列两部分的第一部分。这部分讨论原始类型的对象创建Go 中的 reflect 包提供了根据执行过程中对象的类型来改变程序控制流的 API。reflect 包提供了两个重要的结构 - Type 和 Value。Type 是一个 Go 中任何类型的代表。换句话说，它可以被用于编码任何 Go 类型（例如：int , string , bool , myCust...
golang中struct关于反射tag
paladinosment的专栏
01-10 8981
package main import ( "fmt" "reflect" ) type User struct { name string `json:name-field` age int } func main() { user := &User{"John Doe The Fourth", 20} field, ok := reflect.TypeOf(user).E
golang使用reflect与tag修改结构体参数
weixin_39220714的博客
11-17 1888
eg. 现有结构体Foo如下 type Foo struct { TID string `json:"tid"` Content string `json:"content"` AID string `json:"aid"` Type string `json:"type"` Params map[string]interface{} } 传入map字段，当map的key值与tag中json字段的值一致，且数据类型一致的时候，进行赋值，否则添加到变量Params中 func (foo
golang 的 tag
笔记
08-20 1554
1. 前言 Go的struct声明允许字段附带Tag来对字段做一些标记。 该Tag不仅仅是一个字符串那么简单，因为其主要用于反射场景，reflect包中提供了操作Tag的方法，所以Tag写法也要遵循一定的规则。 2. Tag的本质 2.1 Tag规则 Tag本身是一个字符串，但字符串中却是：以空格分隔的 key:value 对。 key: 必须是非空字符串，字符串不能包含控制字符、空格、引号、冒号。 value: 以双引号标记的字符串 注意：冒号前后不能有空格 如下代码所示，如此写没有实际意
【Go】【反射】反射基本介绍和使用
皮特儿的博客
09-29 1993
运行时（而不是编译）可以动态的获取变量的信息，如变量的类型Type、类型Kind对于结构体变量，可以获取到结构体的字段、Tag、调用结构体对应方法反射可以修改变量的值SetXxx使用反射 import “reflect”Kind()Elem()
go语言通过反射创建结构体、赋值、并调用对应方法
06-01
可以通过 Go 语言的反射包 `reflect` 来创建结构体、赋值和调用对应方法。以下是一个简单的示例： ```go package main import ( "fmt" "reflect" ) type Person struct { Name string Age int } func (p ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值