golang/go语言Go语言之反射

Posted 棉花糖灬

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了golang/go语言Go语言之反射相关的知识,希望对你有一定的参考价值。

本文参考了李文周的博客——Go语言基础之反射

一、反射初识

1. 什么是反射

在计算机科学中,反射是指计算机程序在运行时(run time)可以访问、检测和修改它本身状态和行为的一种能力。用比喻来说,反射就是程序在运行的时候能够观察并修改自己的行为。

2. 使用场景

  • 编写函数时,并不知道调用者传入的参数类型是什么,可能是没约定好,也可能是传入的类型很多,这些类型不能统一表示
  • 有时候需要根据某些条件调用哪个函数,此时需要对函数和函数的参数进行反射,在运行期间动态的执行函数

3. 缺点

  • 反射相关的代码难以阅读
  • Go语言作为一门静态语言,在编码过程中可以发现一些类型错误,但对于反射代码则是无能为力的
  • 反射对性能影响比较大,比正常代码运行速度慢一到两个数量级

二、reflect包

Go语言中的接口值都具有具体类型和具体类型的值两部分信息,而类型(Type)和值(Value)可以理解为定义在reflect包下的两个结构体reflect.Type和reflect.Value。

reflect包下有两个最基础的函数——TypeOf和ValueOf,分别用于获取对象的类型信息和值信息,也即reflect.Type和reflect.Value对象。

函数说明
func TypeOf(i any) Type获取对象的类型信息
func ValueOf(i any) Value获取对象的值信息

1. refelect.TypeOf函数

(1) TypeOf函数

通过relect.TypeOf()函数我们可以获取任意对象的类型信息,即reflect.Type对象。

package main

import (
	"fmt"
	"reflect"
)

func main() 
	var x float64 = 3.4
	fmt.Println("type:",reflect.TypeOf(x)) //type: float64

(2) Type和Kind

反射中的类型可以分为类型(Type)和种类(Kind)两种。类型(Type)是在变量声明时被赋予的类型(静态类型)或者运行时的类型(动态类型,又称具体类型)。而种类(Kind)是指数据底层的类型,种类是有限可枚举的。reflect包下定义的Kind类型包含以下几种:

type Kind uint
const (
    Invalid Kind = iota  // 非法类型
    Bool                 // 布尔型
    Int                  // 有符号整型
    Int8                 // 有符号8位整型
    Int16                // 有符号16位整型
    Int32                // 有符号32位整型
    Int64                // 有符号64位整型
    Uint                 // 无符号整型
    Uint8                // 无符号8位整型
    Uint16               // 无符号16位整型
    Uint32               // 无符号32位整型
    Uint64               // 无符号64位整型
    Uintptr              // 指针
    Float32              // 单精度浮点数
    Float64              // 双精度浮点数
    Complex64            // 64位复数类型
    Complex128           // 128位复数类型
    Array                // 数组
    Chan                 // 通道
    Func                 // 函数
    Interface            // 接口
    Map                  // 映射
    Ptr                  // 指针
    Slice                // 切片
    String               // 字符串
    Struct               // 结构体
    UnsafePointer        // 底层指针
)

反射对象的Kind可以通过reflect.Value或reflect.Type类型对象的Kind()函数获取。reflect.Value或reflect.Type类型对象有很多同名函数,它们有些功能相同,有些在返回值有些许区别,本文后面对此有更多的例子。

2. reflect.ValueOf函数

(1) ValueOf函数

通过reflect.ValueOf()函数我们可以获取任意对象的值信息,即reflect.Value对象,其中包含了原始值的值信息。

package main

import (
	"fmt"
	"reflect"
)

func main() 
	var x float64 = 3.4
	fmt.Println("value:",reflect.ValueOf(x)) //value: 3.4

(2) Value转为原始值

除了可以通过ValueOf()函数将原始值转为reflect.Value对象外,还可以将reflect.Value对象转为原始值,reflect.Value类型提供的获取原始值的方法如下:

方法说明
func (v Value) Interface() interface 将值以 interface 类型返回,可以通过类型断言转换为指定类型
func (v Value) Int() int64将值以 int 类型返回,所有有符号整型均可以此方式返回
func (v Value) Uint() uint64将值以 uint 类型返回,所有无符号整型均可以此方式返回
func (v Value) Float() float64将值以双精度(float64)类型返回,所有浮点数(float32、float64)均可以此方式返回
func (v Value) Bool() bool将值以 bool 类型返回
func (v Value) Bytes() []bytes将值以字节数组 []bytes 类型返回
func (v Value) String() string将值以字符串类型返回

可以发现通过Interface方法获取原始值的方式是最为通用的一种。

3. isNil和isValid方法

由于函数参数传递是值拷贝,所以必须传递变量的地址才能修改变量的值。在反射中可以使用Elem()方法来获取指针对应的值。

(1) isNil方法

func (v Value) IsNil() bool

IsNil()报告v持有的值是否为nil,IsNil()常被用于判断指针是否为空。。v持有的值的分类必须是通道、函数、接口、映射、指针、切片之一;否则IsNil函数会导致panic。

(2) isValid方法

func (v Value) IsValid() bool

IsValid()返回v是否持有一个值,IsValid()常被用于判定返回值是否有效。

(3) 代码示例

func main() 
	// *int类型空指针
	var a *int
	fmt.Println("var a *int IsNil:", reflect.ValueOf(a).IsNil())
	// nil值
	fmt.Println("nil IsValid:", reflect.ValueOf(nil).IsValid())
	// 实例化一个匿名结构体
	b := struct
	// 尝试从结构体中查找"abc"字段
	fmt.Println("不存在的结构体成员:", reflect.ValueOf(b).FieldByName("abc").IsValid())
	// 尝试从结构体中查找"abc"方法
	fmt.Println("不存在的结构体方法:", reflect.ValueOf(b).MethodByName("abc").IsValid())
	// map
	c := map[string]int
	// 尝试从map中查找一个不存在的键
	fmt.Println("map中不存在的键:", reflect.ValueOf(c).MapIndex(reflect.ValueOf("娜扎")).IsValid())

三、结构体反射

如果反射对象的类型是结构体,反射类型reflect.Type和反射值reflect.Value对象提供了对应的方法,来获取结构体的字段信息和方法信息,并且可以通过反射来调用结构体的方法。

1. 与结构体字段、方法相关的方法

下表中所列举的方法,除了Call()函数之外,其他的都是reflect.Value和reflect.Type都有的,只不过reflect.Value的同名函数返回结果的类型都是reflect.Value对象。

方法说明
func (t Type) Field(i int) StructField根据索引,返回索引对应的结构体字段的信息。
func (t Type) NumField() int返回结构体成员字段数量。
func (t Type) FieldByName(name string) (StructField, bool)根据给定字符串返回字符串对应的结构体字段的信息。
func (t Type) FieldByIndex(index []int) StructField多层成员访问时,根据 []int 提供的每个结构体的字段索引,返回字段的信息。
func (t Type) FieldByNameFunc(match func(string) bool) (StructField,bool)根据传入的匹配函数匹配需要的字段。
func (t Type) NumMethod() int返回该类型的方法集中方法的数目
func (t Type) Method(int) Method返回该类型方法集中的第i个方法
func (t Type) MethodByName(string) (Method, bool)根据方法名返回该类型方法集中的方法
func (v Value) Call([]Value) []Value根据传参调用结构体的方法

2. 获取结构体字段信息

(1) StructField类型

在上表中,有些方法的返回值类型为StructField类型,它是用来描述结构体的一个字段信息的,其定义如下:

type StructField struct 
    Name    string      // 字段的名字
    PkgPath string      // 非导出字段的包路径,对于导出字段该字段值为""
    Type      Type      // 字段的类型
    Tag       StructTag // 字段的标签
    Offset    uintptr   // 字段在结构体中的字节偏移量
    Index     []int     // 用于Type.FieldByIndex时的索引
    Anonymous bool      // 是否匿名字段

(2) 获取结构体字段信息步骤

获取结构体字段信息可以分为以下几步:

  • 先获取interface的reflect.Type,然后通过NumField进行遍历
  • 再通过reflect.Type的Field方法根据下标获取其Field
  • 最后通过reflect.Value的Field的Interface()得到对应的value

当然也可以使用FieldByName方法根据字段名获取字段信息。

2. 获取结构体方法信息

(1) Method类型

在上表中,有些方法的返回值类型为Method类型,它是用来描述结构体的一个方法信息的,其定义如下:

type Method struct 
	Name string    // 方法名称
	PkgPath string // 非导出方法的包路径,对于导出方法该字段值为""
	Type  Type     // 方法类型
	Func  Value    // 带有接收器作为第一个参数的方法
	Index int      // 用于Type.MethodByIndex时的索引

(2) 获取结构体方法信息步骤

获取结构体方法信息可以分为以下几步:

  • 先获取interface的reflect.Type,然后通过NumMethod进行遍历
  • 再通过reflect.Type的Method根据下标获取其Method
  • 使用reflect.Value的Call函数调用结构体的Method

当然也可以使用MethodByName方法根据方法名获取方法信息。

3. 代码示例

package main

import (
	"fmt"
	"reflect"
)

// 定义一个结构体
type Person struct 
	Name string `json:"name"`
	Age  int    `json:"age"`
	Sex  string `json:"sex"`


// 注意,如果是指针 *Person 类型,则不算做是 Person 的Method
func (p Person) PrintInfo() 
	fmt.Printf("name:%s, age:%d, sex:%s\\n", p.Name, p.Age, p.Sex)


func (p Person) Say(msg string) 
	fmt.Println("hello,", msg)


func main() 
	p := Person
		Name: "zuzhiang",
		Age:  27,
		Sex:  "female",
	
	getFieldAndMethod(p)


// getFieldAndMethod 通过接口来获取任意参数,并打印结构体的字段和方法信息
func getFieldAndMethod(input interface) 
	getType := reflect.TypeOf(input)           // 获取input的类型
	fmt.Println("Type.Name: ", getType.Name()) // Person
	fmt.Println("Type.Kind: ", getType.Kind()) // struct

	getValue := reflect.ValueOf(input) // 获取input的值
	fmt.Println("Value:", getValue) // zuzhiang 27 female
  fmt.Println("----------------------------------------\\n")

	// 获取结构体字段
	// 1. 先获取interface的reflect.Type,然后通过NumField进行遍历
	// 2. 再通过reflect.Type的Field方法根据下标获取其Field
	// 3. 最后通过reflect.Value的Field的Interface()得到对应的value
	for i := 0; i < getType.NumField(); i++ 
		field := getType.Field(i)
		value := getValue.Field(i).Interface() //获取第i个值
		fmt.Printf("字段名: %s, 字段类型: %s, 字段索引: %d, json tag: %s, 字段值: %v \\n",
			field.Name, field.Type, field.Index, field.Tag.Get("json"), value)
	
  fmt.Println("----------------------------------------\\n")
	
  // 定义函数调用时的参数,Call函数的参数类型必须是[]reflect.Value
	msg := "zuzhiang"
	paramList := make([]reflect.Value, 0)
	paramList = append(paramList, reflect.ValueOf(msg))
	args := [][]reflect.Value
		nil,
		paramList,
	
  
  // 通过反射,操作方法
	// 1. 先获取interface的reflect.Type,然后通过NumMethod进行遍历
	// 2. 再通过reflect.Type的Method根据下标获取其Method
	// 3. 使用reflect.Value的Call函数调用结构体的Method
	for i := 0; i < getType.NumMethod(); i++ 
		method := getType.Method(i)
		fmt.Printf("方法名称: %s, 方法类型: %v \\n", method.Name, method.Type)
    // 函数的顺序按函数名字典序正序排列
		getValue.Method(i).Call(args[i])
		fmt.Println("")
	

以上是关于golang/go语言Go语言之反射的主要内容,如果未能解决你的问题,请参考以下文章

初探go-golang语言初体验

golang/go语言Go语言中的面向对象OOP

1. Go 语言简介

知识分享之Golang——go-i18n国际化组件

golang/go语言Go语言代码实践——高复用易扩展性代码训练

golang/go语言go语言中包的使用Init()函数协程和接口