golang反射(reflect)struct操作

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

golang反射(reflect)struct操作

1、信息获取

reflect提供了两种类型来进行访问接口变量的内容：

类型作用
ValueOf获取输入参数接口中的数据的值，如果为空则返回0 <- 注意是0
TypeOf动态获取输入参数接口中的值的类型，如果为空则返回nil <- 注意是nil

2、示例代码

package main

import (
	"fmt"
	"reflect"
)

type Person struct {
	Name  string `json:"name"`
	Count int
}

func main() {
	test(Person{
		Name:  "lei",
		Count: 2,
	})
}

func test(body interface{}) {
	//TypeOf会返回目标数据的类型，比如int/float/struct/指针等
	typ := reflect.TypeOf(body)
	//ValueOf返回目标数据的的值
	val := reflect.ValueOf(body)
	if val.Kind() != reflect.Struct {
		fmt.Println("expect struct")
		return
	}
	fmt.Println(typ)
	fmt.Println(val)
	for i := 0; i < val.NumField(); i++ {
		field := typ.Field(i) //字段的数据类型
		value := val.Field(i) //字段的数据值
		fmt.Println("type1:", field) //type: {Name  string json:"name" 0 [0] false}
		fmt.Println("value1:", value) //value: lei
		switch value.Kind() {
		case reflect.Int:
			value.SetInt(88) //往该字段设值
		case reflect.String:
            //这里存在一个问题无法对字段进行值修改，panic:reflect: reflect.flag.mustBeAssignable using unaddressable value,后文介绍解决
			value.SetString("Test") // 往该字段设值
		default:
			fmt.Println("类型不支持")
		}
		fmt.Println("type2:", field) //type: {Name  string json:"name" 0 [0] false}
		fmt.Println("value2:", value) //value: Test
		tag := field.Tag
		fmt.Println(tag.Get("json"))
	}
}

3、函数说明

3.1、val.Kind()

// Kind returns v's Kind.
// If v is the zero Value (IsValid returns false), Kind returns Invalid.
func (v Value) Kind() Kind {
	return v.kind()
}

返回值为Kind,表示golang语言自身定义的基本类型:

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
)

3.2、val.NumField()

// NumField returns the number of fields in the struct v.
// It panics if v's Kind is not Struct.
func (v Value) NumField() int {
	v.mustBe(Struct)
	tt := (*structType)(unsafe.Pointer(v.typ))
	return len(tt.fields)
}

返回值为int，v.mustBe(Struct) 值类型必须为一个struct，该方法函数表示获取结构体中字段的数量。

3.3、typ.Field(i)

// Field returns a struct type's i'th field.
// It panics if the type's Kind is not Struct.
// It panics if i is not in the range [0, NumField()).
type Type interface {
	Field(i int) StructField	
}

反射的类型接口，该接口实现了获取指定结构体参数当中的某下标 i 的字段信息:

// A StructField describes a single field in a struct.
type StructField struct {
	// Name is the field name.
	Name string
	// PkgPath is the package path that qualifies a lower case (unexported)
	// field name. It is empty for upper case (exported) field names.
	// See https://golang.org/ref/spec#Uniqueness_of_identifiers
	PkgPath string
	Type      Type      // field type
	Tag       StructTag // field tag string
	Offset    uintptr   // offset within struct, in bytes
	Index     []int     // index sequence for Type.FieldByIndex
	Anonymous bool      // is an embedded field
}

field.Tag 是取到该字段标签信息 StructTag，它又具备两个对外暴露的方法:

// 只是复用了Lookup，只不过忽略了标签存在的说明，不存在返回“”
func (tag StructTag) Get(key string) string {
	v, _ := tag.Lookup(key)
	return v
}
// 返回标签对应的值与标签是否存在的说明
func (tag StructTag) Lookup(key string) (value string, ok bool) {
	// When modifying this code, also update the validateStructTag code
	// in cmd/vet/structtag.go.
	...
}

_3.4、_value.SetString(“Test”)

reflect包提供了方法对Value实例中的字段值做出修改，值得注意的是，根据官方描述，为了改变一个反射对象，其值必需是可修改的，这里的可修改值得注意，通过输入的接口初始化的Value实例，返回一个根据输入的接口中存储的值初始化的新Value类型（跟按值传递参数一致），因此，对Value中的值做出修改并没有改变外部接口值，因此并不支持value.SetString("Test")
错误信息：panic: reflect: reflect.flag.mustBeAssignable using unaddressable value
因此如果对于值的修改要以指针传递参数&Person 形式，可使用Elem()函数将用指针量初始化的Value实例中实际存储的值（相当于引用传递，这里的Elem()相当于一个解引用）
修改后的示例代码：

package main

import (
	"fmt"
	"reflect"
)

type Person struct {
	Name  string `json:"name"`
	Count int
}

func (p *Person) Print() {
	fmt.Println("print:",p)
}

func (p *Person) CountAdd(num int) int {
	return p.Count + num
}

func main() {
	test(&Person{
		Name:  "lei",
		Count: 2,
	})
}

func test(body interface{}) {
	//TypeOf会返回目标数据的类型，比如int/float/struct/指针等
	typ := reflect.TypeOf(body)
	//ValueOf返回目标数据的的值
	val := reflect.ValueOf(body)
	if val.Elem().Kind() != reflect.Struct {
		fmt.Println("expect struct")
		return
	}
	fmt.Println(typ)
	fmt.Println(val)
	for i := 0; i < val.Elem().NumField(); i++ {
		field := typ.Elem().Field(i) //字段的数据类型
		value := val.Elem().Field(i) //字段的数据值
		fmt.Println("type1:", field) //type: {Name  string json:"name" 0 [0] false}
		fmt.Println("value1:", value) //value: lei
		switch value.Kind() {
		case reflect.Int:
			value.SetInt(88) //往该字段设值
		case reflect.String:
			value.SetString("Test") // 往该字段设值
		default:
			fmt.Println("类型不支持")
		}
		fmt.Println("type2:", field) //type: {Name  string json:"name" 0 [0] false}
		fmt.Println("value2:", value) //value: Test
		fmt.Println(field.Tag.Get("json"))
	}
}

4、方法调用

4.1、val调用

call := val.Method(0).Call([]reflect.Value{reflect.ValueOf(2)}) //调用CountAdd方法
fmt.Println("返回值：", call[0])                                    //返回值： 90
val.MethodByName("Print").Call(nil)                             //通过方法名调用

除解析一个接口的结构字段和方法外，还可以对注册在结构上的方法进行调用，调用过程中需要注意接收者是否为指针型，被调用函数应当是被导出类型，调用过程只能在包含了结构实例值的Value类型上使用，type类型无法使用，func (v Value) Call(in []Value) []Value， 参数和返回值都是reflect包中Value型的切片，需要经过转换。

4.2、typ查看方法信息

for i := 0; i < typ.NumMethod(); i++ {
		method := typ.Method(i)
		fmt.Println(method.Name,method.Type) //CountAdd func(*main.Person, int) int
}

typ.Method(i) 其返回值包含该指向方法的基本信息：

// Method represents a single method.
type Method struct {
	// Name is the method name.
	// PkgPath is the package path that qualifies a lower case (unexported)
	// method name. It is empty for upper case (exported) method names.
	// The combination of PkgPath and Name uniquely identifies a method
	// in a method set.
	// See https://golang.org/ref/spec#Uniqueness_of_identifiers
	Name    string
	PkgPath string

	Type  Type  // method type
	Func  Value // func with receiver as first argument
	Index int   // index for Type.Method
}

4.3、typ方法调用

for i := 0; i < typ.NumMethod(); i++ {
	method := typ.Method(i)
	fmt.Println(method.Name,method.Type) //CountAdd func(*main.Person, int) int
	if method.Name == "CountAdd" {
		//对于Type类型包含的方法，因为没有实际值作为接收者，需要吧传入的第一个参数作为接收者
		retInfo := method.Func.Call([]reflect.Value{val,reflect.ValueOf(2)})
		fmt.Println("返回值：", retInfo[0])
	}
}
method, ok := typ.MethodByName("Print")
if ok {
	method.Func.Call([]reflect.Value{val})
}

5、完整示例代码

package main

import (
	"fmt"
	"reflect"
)

type Person struct {
	Name  string `json:"name"`
	Count int
}

func (p *Person) Print() {
	fmt.Println("print:", p) //print: &{Test 88}
}

func (p *Person) CountAdd(num int) int {
	return p.Count + num
}

func main() {
	test(&Person{
		Name:  "lei",
		Count: 2,
	})
}

func test(body interface{}) {
	//TypeOf会返回目标数据的类型，比如int/float/struct/指针等
	typ := reflect.TypeOf(body)
	//ValueOf返回目标数据的的值
	val := reflect.ValueOf(body)
	if val.Elem().Kind() != reflect.Struct {
		fmt.Println("expect struct")
		return
	}
	fmt.Println(typ)
	fmt.Println(val)
	for i := 0; i < val.Elem().NumField(); i++ {
		field := typ.Elem().Field(i)  //字段的数据类型
		value := val.Elem().Field(i)  //字段的数据值
		fmt.Println("type1:", field)  //type: {Name  string json:"name" 0 [0] false}
		fmt.Println("value1:", value) //value: lei
		switch value.Kind() {
		case reflect.Int:
			value.SetInt(88) //往该字段设值
		case reflect.String:
			value.SetString("Test") // 往该字段设值
		default:
			fmt.Println("类型不支持")
		}
		fmt.Println("type2:", field)  //type: {Name  string json:"name" 0 [0] false}
		fmt.Println("value2:", value) //value: Test
		fmt.Println(field.Tag.Get("json"))
	}
	//   除解析一个接口的结构字段和方法外，还可以对注册在结构上的方法进行调用
	//   调用过程中需要注意接收者是否为指针型，被调用函数应当是被导出类型
	//   这个调用过程只能在包含了结构实例值的Value类型上使用，Type类型无法使用
	//    func (v Value) Call(in []Value) []Value
	//   参数和返回值都是reflect包中Value型的切片，需要经过转换
	call := val.Method(0).Call([]reflect.Value{reflect.ValueOf(2)}) //调用CountAdd方法
	fmt.Println("返回值：", call[0])                                    //返回值： 90
	val.MethodByName("Print").Call(nil)                             //通过方法名调用
	for i := 0; i < typ.NumMethod(); i++ {
		method := typ.Method(i)
		fmt.Println(method.Name,method.Type) //CountAdd func(*main.Person, int) int
		if method.Name == "CountAdd" {
			//对于Type类型包含的方法，因为没有实际值作为接收者，需要吧传入的第一个参数作为接收者
			retInfo := method.Func.Call([]reflect.Value{val,reflect.ValueOf(2)})
			fmt.Println("返回值：", retInfo[0])
		}
	}
	method, ok := typ.MethodByName("Print")
	if ok {
		method.Func.Call([]reflect.Value{val})
	}
}
夜寒听雨
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
golang通过反射创建结构体
Zhanyia的博客
10-15 7854
通过反射创建结构体 练习通过反射创建结构体时写的代码 package main import ( "fmt" "reflect" ) type Student struct { Name string `json:"name"` Id int `json:"id"` } func main() { var ( model *Student st reflect.Typ...
go如何通过包名动态创建结构体
最新发布
leijmdas的专栏
07-20 250
请注意，这个示例代码使用了 importlib.Important 函数，这是一个假设的函数，实际上Go标准库中并没有这个函数。在Go中，动态导入包通常是通过 import() 函数实现的，但是它只能在初始化函数中使用，并且不能直接返回包对象。在Go语言中，通过包名字符串动态地创建一个结构体实例涉及到反射（reflection）的使用。在实际应用中，你可能需要更复杂的逻辑来确定结构体的名称，或者处理不同的错误情况。// 假设我们有一个名为"mypackage"的包，其中定义了一个结构体MyStruct。
golang 通过reflect反射方式调用对象方法 (动态方法调用) 详解
06-28 698
反射中的2种途径都可以调用对象的方法， 一种是通过先获取方法的数量，然后循环调用全部方法， 另外一种是通过具体的方法名称直接获取 reflect.Value 后调用对象方法。这个过程中需要注意的是，如果对象为指针类型，则需要先调用 .Elem() 方法获取指针指向的具体值后再操作。而对于有参数的方法调用相对复杂，这个一般不常用，知道大概流程即可。
2024年力扣热门100题之字母异位词分组【中等】(1)，2024年最新微信小程序页面跳转方法总结
2401_84910943的博客
05-11 468
输入: strs = [“eat”, “tea”, “tan”, “ate”, “nat”, “bat”]输出: [[“bat”],[“nat”,“tan”],[“ate”,“eat”,“tea”]]解法1：字符串拆分后排序，再聚合，最后再使用哈希归类。输入: strs = [“a”]解法2：求字符串权值，按权值分类。输入: strs = [“”]strs[i] 仅包含小写字母。输出: [[“a”]]输出: [[“”]]
Golang使用reflect操作struct
pascal_lin
12-24 1080
Golang的Reflect包是做什么用的? Reflection in computing is the ability of a program to examine its own structure, particularly through types;it’s a form of metaprogramming 反射是程序检查其自身结构的能力，尤其是通过类型；它是元编程的一种形式。 From The Go Blog - The Laws of Reflection 上面是反射的定义，也就是
golang reflect struct
weixin_30372371的博客
01-31 53
import ( "fmt" "reflect" ) type Foo struct { FirstName string `tag_name:"tag 1"` LastName string `tag_name:"tag 2"` Age int `tag_name:"tag 3"` } func (f ...
golang：reflect
OceanStar的博客
02-28 301
引入 反射机制是程序能够检测其自身结果，属于元编程的范畴，强大的同时也往往是困扰的源头。虽然各种语言的反射模型有所不同，但是通过简单的比较也能有所收获。虽然各种语言的反射模型有所不同，但是通过简单的比较也能有所收获。在了解Go的反射机制之前先来看看Java的反射机制吧。 java的反射机制： 我们所熟知的java的反射机制是什么？对于类和对象的使用，普通的方式是知道类和对象的属性和方法之后进行调...
golang 通过reflect 获取struct信息
无风的雨
05-06 5058
本示例主要通过反射，了解struct或变量的相关信息，方便在查看代码中某个变量信息。 示例： package main import ( "fmt" "reflect" ) type Users struct { Id int Name string Age int Mark...
Golang通过反射获取结构体的标签
weixin_30379911的博客
02-14 333
Golang通过反射获取结构体的标签 例子： package main import ( "fmt" "reflect" ) type resume struct { Name string `json:"name" doc:"我的名字"` } func findDoc(stru interface{}) map[string]string...
详解Golang利用反射reflect动态调用方法
09-19
### Golang 反射 Reflect 动态调用方法详解 #### 一、引言 反射是许多现代编程语言中的一项重要特性，它允许程序在运行时检查和操作自身的内部结构。Go 语言同样具备这样的能力，它通过 `reflect` 包提供了一套...
golang 使用反射实现获取struct的field内容
lackystd的专栏
01-07 1695
go语言 使用反射获取struct的field内容
golang struct 自动生成工具
04-29
开源地址 https://github.com/whr-helen/go-struct-auto 自动构建工具使用 安装包命令：go get github.com/whr-helen/go-struct-auto 注释：参数信息 -host host改为自己数据库的地址（默认127.0.0.1） -port port改为自己数据库的端口（默认3306） -acc acc改为自己数据库的账号（默认root） -pwd pwd改为自己数据库的密码（默认123123） -d dbname改为自己数据库的名称（必填） -path ./models改为存放路径（可选默认为./models） -t account，user改为要生成的表名称，可多个（可选默认全部生成） 一，生成数据库所有表结构体： ①推荐使用方法（支持linux或mac） 生成命令：./ bin / auto -d dbname -path ./models ②修改生成工具代码（支持linux或mac或windows）如果生成出来的结构不是我们所需要的可以修改automatic.go文件 命令：go run automatic.go -d dbname -path ./models 二，生成单个多个表结构体： 命令（支持linux或mac）：./ bin / auto -d dbname -t account，user 命令（支持linux或mac或windows）：go run automatic.go -d dbname -acc root -pwd 123123 -t account
golang 反射（reflect）
pmlpml的专栏
12-20 2219
反射是现代程序必备的元素，用于在运行时获取程序元数据，实现动态识别类型及其结构，以及相关的语义信息。
Golang基础之Struct
叱咤少帅的博客
03-31 458
Golang 之Struct
go reflect struct 遍历,反射
weixin_33709590的博客
07-21 1140
为什么80%的码农都做不了架构师？>>> ...
golang中反射知识点浅析
架构师实战感悟
03-07 1559
1.reflect简介反射，就是在程序运行过程中，能够获取任意一个类的属性，方法；对任意一个类，能够调用他的任意方法和属性。这是一个比较官方的解说。个人觉得通俗易懂的解释是：“通过一个给定的变量对象，获取这个变量的类型，这个类型的属性，方法”2.重要接口与类golang中reflect包package reflect重要接口type Type interface{}重要类type Value str
Golang——reflect(反射)
weixin_57023347的博客
05-18 705
反射是指在对程序本身进行访问和修改的能力。
Golang学习笔记5——反射
Overvautious的博客
05-12 698
文章目录1. 反射是什么1.1 概念1.2 功能2. 反射的实现2.1 interface 和 反射2.2 Golang的反射reflect2.2.1 reflect的基本功能TypeOf和ValueOf2.3 获取接口的属性和方法2.3.1 从relfect.Value中获取接口interface的信息2.3.2 已知原有类型2.3.3 未知原有类型【遍历探测其Filed】2.4 通过reflect.Value设置实际变量的值2.5 通过reflect.ValueOf来进行方法的调用3. Golang的反
go学习 --- 使用反射获取结构体字段属性
qq_46093575的博客
02-11 3263
一、使用反射获取指针结构体与结构体的区别 package main import ( "fmt" "reflect" ) type hello struct { } func main() { //指针结构体 h := &hello{} refH := reflect.TypeOf(h) fmt.Println(refH.PkgPath()) fmt.Println(refH.Kind()) fmt.Println(refH.Name()) fmt.Println(ref
golang 遍历struct
07-28
在Go语言中，可以使用反射来遍历一个结构体(struct)的字段。以下是一个示例代码： ```go package main import ( "fmt" "reflect" ) type Person struct { Name string Age int Gender string } func main() { person := Person{ Name: "Alice", Age: 30, Gender: "Female", } // 获取结构体的反射类型 structType := reflect.TypeOf(person) // 获取结构体的反射值 structValue := reflect.ValueOf(person) // 遍历结构体的字段 for i := 0; i < structType.NumField(); i++ { field := structType.Field(i) value := structValue.Field(i) fmt.Printf("Field Name: %s, Field Value: %v\n", field.Name, value.Interface()) } } ``` 输出结果为： ``` Field Name: Name, Field Value: Alice Field Name: Age, Field Value: 30 Field Name: Gender, Field Value: Female ``` 这里使用了反射的 `reflect.TypeOf` 和 `reflect.ValueOf` 函数来获取结构体的类型和值。然后使用 `NumField` 方法获取结构体的字段数量，并通过循环遍历每个字段，使用 `Name` 属性获取字段名，使用 `Interface` 方法获取字段的值。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值