Golang - 反射

最新推荐文章于 2022-10-07 18:00:00 发布
最新推荐文章于 2022-10-07 18:00:00 发布
阅读量154 收藏
点赞数
分类专栏： # golang
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yang_kaiyue/article/details/94467063
版权

反射调用方法

package main

import (
	"fmt"
	"reflect"
)

type stu struct {
	name  string
	score int
}

func (s *stu) SetScore(newScore int) {
	s.score = newScore
}

func (s stu) S1() int {
	return 100
}

// k 是为了模拟反射时传参
func (s stu) S2(k string) (string, int) {
	return k, s.score
}

func main() {
	s := stu{
		name:  "Tim",
		score: 99,
	}

	// Value..MethodByName 也只会找暴露给外部且值类型接收的方法
	// 就是只能找到 S1, S2 方法, 无法找到 SetScore 方法
	v1 := reflect.ValueOf(s).MethodByName("S1")

	// 如果方法存在则继续
	if v1.IsValid() {
		// 当方法没有参数时, 需要传 nil, 返回是个切片需要靠索引取值
		r := v1.Call(nil) // 传这个 []reflect.Value{} 也行
		fmt.Println(r[0])
	}

	v2 := reflect.ValueOf(s).MethodByName("S2")

	if v2.IsValid() {
		args := reflect.ValueOf("Tim")       // 用 ValueOf() 创建 Value, 且 "Tim" 是传给实际方法的参数
		r2 := v2.Call([]reflect.Value{args}) // Call() 的参数必须是 []Value, 所以上一步要造 Value 类型
		fmt.Println(r2[0], r2[1])            // 索引取值
	}
}

TypeOf

  • 根据变量名获取变量类型
package main

import (
	"fmt"
	"reflect"
)

func main() {
	a := 10

	t := reflect.TypeOf(a)

	fmt.Printf("%T, %[1]v\n", t)          // *reflect.rtype, int
	fmt.Printf("%T, %[1]v\n", t.String()) // string, int
}

方法

类型相关 - Kind(), Name()

  • 任何的数据类型: kind 都是基础类型名
  • 基础数据类型: Name 为空, Kind 为基础类型名
  • 自定义数据类型: Name 为 自定义数据类型名, Kind 为对应的基础数据类型名
  • 类型别名: Name 和 Kind 都是对应的基础数据类型名
package main

import (
	"fmt"
	"reflect"
)

type cat struct{}

type newInt int

type myNewInt = int

func main() {
	// 列出几种不同的数据
	var a int      // 基础 值类型
	var b []int    // 基础 引用类型
	var c cat      // 自定义 值类型
	var d newInt   // 自定义类型
	var e myNewInt // 类型别名

	// 拿到一个 interface t, 可以直接打印, 输出类型
	t1 := reflect.TypeOf(a)
	fmt.Println(t1)

	// String(), 获取类型
	r := t1.String()
	fmt.Println(r)

	// Kind()
	// 1. 当数据为基础类型时, Kind 没有变化
	ret := reflect.TypeOf(b)
	fmt.Printf("String(): %v, Kind(): %v, Name(): %v\n", ret.String(), ret.Kind(), ret.Name()) // String(): []int, Kind(): slice, Name():

	// 2. 当数据为自定义类型时, Kind 为其对应的基础类型
	ret = reflect.TypeOf(c)
	fmt.Printf("String(): %v, Kind(): %v, Name(): %v\n", ret.String(), ret.Kind(), ret.Name()) // String(): main.cat, Kind(): struct, Name(): cat
	ret = reflect.TypeOf(d)
	fmt.Printf("String(): %v, Kind(): %v, Name(): %v\n", ret.String(), ret.Kind(), ret.Name()) // String(): main.newInt, Kind(): int, Name(): newInt

	// 3. 类型别名, 同对应的类型
	ret = reflect.TypeOf(e)
	fmt.Printf("String(): %v, Kind(): %v, Name(): %v\n", ret.String(), ret.Kind(), ret.Name()) // String(): int, Kind(): int, Name(): int
}

属性相关 - Field(), FieldByName(), FieldByIndex()

package main

import (
	"fmt"
	"reflect"
)

// Person 测试结构体
type Person struct {
	Name string `json:"name"`
	Age  int    `json:"age"`
}

// Stu 测试结构体
type Stu struct {
	Score int
	// 这种就是匿名引用, 如果是 Person Person, 就不是匿名引用, 第一个 Person 为命名, 第二个为指定的结构体类型
	Person
}

func main() {
	// 实例化
	stu1 := Stu{
		Score: 100,
		Person: Person{
			Name: "Tim",
			Age:  30,
		},
	}

	// 拿到 Type
	t := reflect.TypeOf(stu1)

	// 取属性, 方式1, 根据索引
	sf1 := t.Field(1)
	// {Person  main.Person  8 [1] true}, 这个 true 说明 stu 结构体中的 person 结构体是匿名引用
	fmt.Println(sf1)

	// 取属性, 方式2, 根据 key
	sf2, ok := t.FieldByName("Person")
	if ok {
		fmt.Println(sf2)
	}

	// 根据索引取嵌套的属性
	sf3 := t.FieldByIndex([]int{1, 1})
	fmt.Println(sf3)

	// 上边三个返回值是 StructField 结构体, {Age  int json:"age" 16 [1] false}, 以这个举例
	fmt.Println(sf3.Name)  // Age, 结构体属性名
	fmt.Println(sf3.Type)  // int, 结构体属性数据类型
	fmt.Println(sf3.Tag)   // json:"age", 结构体属性 json tag
	fmt.Println(sf3.Index) // [1], 属性在当前结构体的索引
}

方法相关 - NumMethod(), Method(), MethodByName()

  • NumMethod() 这个方法只统计暴露给外部,并且是值接收者的方法
package main

import (
	"fmt"
	"reflect"
)

type stu struct {
	name  string
	age   int
	score int
}

func (s stu) Study() string {
	return "study"
}

func (s *stu) ChangeScore(newScore int) {
	s.score = newScore
}

func main() {
	stu1 := stu{
		name:  "Tim",
		age:   18,
		score: 100,
	}

	t := reflect.TypeOf(stu1)

	// 获取方法数量, 这个方法只统计暴露给外部,并且是值接收者的方法
	numMethod := t.NumMethod()

	for i := 0; i < numMethod; i++ {
		// 根据索引
		fmt.Println(t.Method(i).Name)
	}

	// 根据字符串取方法
	m, ok := t.MethodByName("Study")
	if ok {
		fmt.Println(m.Name)
	}
}

源码

TypeOf 实现

func TypeOf(i interface{}) Type {
	eface := *(*emptyInterface)(unsafe.Pointer(&i))
	return toType(eface.typ)
}

Type接口

type Type interface {
	String() string                              // 直接打印就是这个
	
	Kind() Kind                                  // 返回种类
	Name() string                                // 返回类型
	
	Elem() Type                                  // 获取指针对应的值
	
	NumField() int                               // 获取属性数量
	Field(i int) StructField                     // 根据索引获取属性
	FieldByIndex(index []int) StructField        // 根据索引获取多个属性
	FieldByName(name string) (StructField, bool) // 根据字符串获取属性
	
	NumMethod() int                              // 获取方法数量
	Method(int) Method                           // 根据索引获取方法
	MethodByName(string) (Method, bool)          // 根据字符串获取方法
	
	FieldByNameFunc(match func(string) bool) (StructField, bool)
	Align() int
	FieldAlign() int
	PkgPath() string
	Size() uintptr
	Implements(u Type) bool
	AssignableTo(u Type) bool
	ConvertibleTo(u Type) bool
	Comparable() bool
	Bits() int
	ChanDir() ChanDir
	IsVariadic() bool
	In(i int) Type
	Key() Type
	Len() int
	NumIn() int
	NumOut() int
	Out(i int) Type
	common() *rtype
	uncommon() *uncommonType
}

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位复数类型
    String               // 字符串
    Func                 // 函数
    // 以下类型Name()返回为空
    Array                // 数组
    Chan                 // 通道
    Interface            // 接口
    Map                  // 映射
    Ptr                  // 指针
    Slice                // 切片
    Struct               // 结构体
    UnsafePointer        // 底层指针
)

StructField类型源码

// Field, FieldByIndex, FieldByName 返回值都是StructField

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
}

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
}

ValueOf

  • 根据变量名获取值
package main

import (
	"fmt"
	"reflect"
)

func main() {
	a := 10

	// 拿到 Value
	v := reflect.ValueOf(a)

	// 这里输出的就是值
	fmt.Println(v)
}

方法

类型相关 - Kind()

  • Value 可以调用 Type(), 得到一个 Type
  • Value 和 Type 都可以使用 Kind() 方法, 用法相同
package main

import (
	"fmt"
	"reflect"
)

func main() {
	var a int8
	a = 18

	// ValueOf(a) --> Value.Kind() --> Type
	v := reflect.ValueOf(a).Kind()
	fmt.Println(v.String())  // int8
}

修改值 - Elem()

package main

import (
	"fmt"
	"reflect"
)

func main() {
	a := 10
	
	// 拿到 Value
	e := reflect.ValueOf(&a).Elem()
	k := e.Kind()

	// 对应类型, 选择相应的修改方法进行修改
	switch k {	
	case reflect.Int:
		e.SetInt(100)
	default:
		fmt.Println("not string")
	}
	
	// 验证结果, 100
	fmt.Println(a)
}

检查

判断指针是否为空 - isNil()

  • 单独声明的指针, isNil 结果为 True
  • ValueOf() 的参数必须是指针
package main

import (
	"fmt"
	"reflect"
)

func main() {
	// 值类型
	var a1 int
	fmt.Println(reflect.ValueOf(&a1).IsNil()) // false

	var a2 *int
	fmt.Println(reflect.ValueOf(a2).IsNil()) // true

	var a3 = 100
	fmt.Println(reflect.ValueOf(&a3).IsNil()) // false

	// 引用类型
	var b1 []int
	fmt.Println(reflect.ValueOf(&b1).IsNil()) // false

	var b2 *[]int
	fmt.Println(reflect.ValueOf(b2).IsNil()) // true

	var b3 = []int{1, 2, 3}
	fmt.Println(reflect.ValueOf(&b3).IsNil()) // false
}

isValid() - 判断是否存在

  • struct 中查找方法或属性是否存在
    package main

import (
	"fmt"
	"reflect"
)

type stu struct {
	name  string
	score int
}

func (s *stu) SetScore(newScore int) {
	s.score = newScore
}

func (s stu) GetScore() int {
	return s.score
}

func main() {
	stu1 := stu{
		name:  "花花",
		score: 108,
	}

	v := reflect.ValueOf(stu1)

	// 查找字段是否存在
	fmt.Println(v.FieldByName("name").IsValid())

	// 查找方法是否存在
	fmt.Println(v.MethodByName("SetScore").IsValid())
}
  • map 中查找 key 是否存在
    package main

import (
	"fmt"
	"reflect"
)

func main() {
	// map 中查找 key 是否存在
	m := make(map[string]int, 5)

	m["Tim"] = 100
	m["Tom"] = 99

	v2 := reflect.ValueOf(m)
	valid := v2.MapIndex(reflect.ValueOf("Tim")).IsValid()
	fmt.Println(valid)
}

相关源码(部分)

// 返回值类型为Value
type Value struct {
	typ *rtype
	ptr unsafe.Pointer
	flag // uintptr
}

// 从指针取值
func (v Value) Elem() Value {}

// 修改值, 将数据以相应数据类型返回
func (v Value) Int() int64 {}
func (v Value) Float() float64 {}
func (v Value) Bool() bool {}
func (v Value) Uint() uint64 {}
func (v Value) Interface() interface{} {}
func (v Value) String() string {}
func (v Value) Bytes() []byte {}

// 检查
func (v Value) IsNil() bool {}
func (v Value) IsValid() bool {}

// 属性相关
func (v Value) Field(i int) Value {}
func (v Value) FieldByIndex(index []int) Value {}
func (v Value) FieldByName(name string) Value {}

// 方法相关
func (v Value) Method(i int) Value {}
func (v Value) NumMethod() int {}
func (v Value) MethodByName(name string) Value {}
func (v Value) Call(in []Value) []Value {}

// Map相关
func (v Value) MapIndex(key Value) Value {}
func (v Value) MapKeys() []Value {}

// 和TypeOf().Kind()相同, 使用哪个都行
func (v Value) Kind() Kind {}
Golang-反射01
船长的博客
10-11 152
反射的示意图 反射的重要函数 1.reflect.TypeOf()获取变量类型，返回reflect.Type类型 2.reflect.ValueOf()获取变量的值，返回reflect.Value类型 3.反射中 变量 空接口 reflect.Value可以相互转换
golang-反射（reflect）
weixin_43867700的博客
10-29 488
TypeOf()和ValueOf()函数 TypeOf() 这个函数可以接收任何类型的参数，会返回一个该参数的相关参数（接口类型） ValueOf 这个函数可以传入任意类型的参数，能够返回一个结构体类型 这里绑定ValueOf函数传入参数返回的value结构体 可以使用该结构体绑定的相应方法如下所示： 反射入门： 下边两图为反射类型转换的重要图示...
反射
kismile
09-06 152
反射 reflect包的俩种方法 TypeOf Type Name和Type Kind ValueOf 通过反射获取值 通过反射设置变量的值 isNil()和isValid() 结构体反射 StructField类型 通过结构体反射获取实例的全部方法 反射 反射的介绍： ​ 程序中会使用type关键字定义很多自定义类型，可以用反射来区别是...
golang-反射
flowerxxxxx的博客
08-25 88
eg package main import ( "encoding/json" "fmt" ) // json type person struct { Name string `json:"name"` Age int `json:"age"` } func main() { str := `{"name": "John", "age":9000}` var p person fmt.Println(str) json.Unmarshal([]byte(str), &p.
golang-反射reflect
mac的博客
09-24 118
TypeOf() reflect.TypeOf(a) //如果a是具体的类型变量返回具体的类型信息 //如果a是一个接口类型，且绑定具体的类型实例，返回接口的动态类型（绑定的具体实例） //如果a是一个接口类型，没有绑定具体的类型实例，返回静态类型信息 package main import ( "fmt" "reflect" ) type A1 interface { } type INT...
Golang--反射--reflect
JaweG
04-28 539
反射 reflect 反射是指程序运行期间对程序本身进行访问和修改的能力。⇒ 程序在编译时，变量被转换为内存地址，变量名不会被编译器写入到可执行部分。在运行程序时，程序无法获取自身的信息 支持反射的语言，可以在程序编译期间将变量的反射信息，如：字段名称、类型信息、结构体信息等整合到可执行文件中，并给程序提供接口访问反射信息，这样就可以在程序运行期间获取类型的反射信息，并且有能力修改它们。 概括为一句话：反射就是在运行时动态的获取一个变量的类型信息和值信息 1. reflect.Typeof 获得任意值的
golang-反射机制
Cheng_Han_的专栏
09-06 760
1，写数据库dao层的时候用到了反射机制。在反射的时候要注意你的对象时指针还是结构体这样区别也很大。以下接受几种常用的放射方法 reflect.type of package main import ( "fmt" "reflect" ) type hehe struct { NameFile string "PrimaryKey" age int } func mai
【语言知识】golang--反射应用
weixin_41198062的博客
05-07 206
反射 将[]interface{}中信息读取出来 func main() { s := "abc" var is []interface{} //i := s is = append(is, s) fmt.Printf("is is %v\n", is) val := reflect.ValueOf(is) fmt.Printf("val type is %v, value is %v\n", val.Kind(), val) switch val.Kind() { case refle
Golang-11反射(reflect)
凯歌响起的博客
10-07 584
反射是指在程序运行期对程序本身进行访问和修改的能力。程序在编译时，变量被转换为内存地址，变量名不会被编译器写入到可执行部分。在运行程序时，程序无法获取自身的信息。主要还是使用golang默认的reflect进行演示与对应的操作。
golang--reflect反射与字段相关的操作
yh13750507646na的博客
07-12 969
一、通过reflect获取结构体字段名、字段类型和字段值 //获取结构体的类型：需要导入reflect包 package main import ( "fmt" "reflect" ) //定义一个结构体 type UserData struct { Id int Name string } func main() { //创建结构体的对象 data := UserDat...
桫哥-GOlang-09反射
06-12
在本课程"桫哥-GOlang-09反射"中，我们将深入探讨Go语言的反射(reflection)机制，这是Go编程语言中一个非常强大的特性。反射允许程序在运行时检查和修改其自身的行为，这对于创建高度灵活和动态的软件系统来说至关...
GoLang-从入门到实战-经典教程
最新发布
09-05
第1章 介绍和安装 1 - 介绍和安装 ...Go高级实践：反射3定律 Go调度器系列（1）起源 Go调度器系列（2）宏观看调度器 Go调度器系列（3）图解调度原理 Go调度器系列（4）源码阅读与探索 实战Go内存泄露
Golang---Exploration:Eksplorasi di GO
03-06
3. Go的反射(reflect)和类型断言，允许在运行时检查和操作类型。 4. Go的标准库，如net/http包用于构建HTTP服务器和客户端。 5. Go的测试框架，如何编写单元测试和集成测试。 通过这次探索，你将不仅学习到Go语言的...
golang-china读书笔记
08-04
- **为何需要反射**: 解释了反射在某些场景下的必要性。 - **reflect.Type和reflect.Value**: 介绍这两个反射API的基本用法。 - **示例**: 通过具体的例子来说明反射的应用场景。 #### 底层编程 - **底层类型**: ...
Golang - map和切片混用
yang_kaiyue的博客
05-23 5659
[map map map], map[string][]int
Golang - 自定义类型和类型别名
yang_kaiyue的博客
06-04 3504
自定义类型 --> 给类型添加自定义的方法; 类型别名 --> 提高代码可读性
kingpin 包
yang_kaiyue的博客
01-21 2745
kingpin 的基本使用, 类似 flag 包
Golang - 环境搭建及编译器设置
yang_kaiyue的博客
05-15 2177
go环境搭建 vscode编译器配置 运行第一个go程序
golang
yang_kaiyue的博客
05-15 1397
-
golang 反射原理
06-10
Golang 的反射（reflection）是指在运行时动态地获取一个变量的类型信息和值信息，并且可以通过反射修改变量的值或调用变量的方法。Golang 的反射是通过 reflect 包来实现的。 反射的原理主要是通过 Type 和 Value ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值