go--反射&常量

时间：2021-10-24 01:21:37

适配器函数

bridge := func(call interface{},args ...interface{}){
  //内容
}

反射基本介绍

package reflect

go--反射&常量

//官网relect的Type
type Type interface {
    // Kind返回该接口的具体分类
    Kind() Kind
    // Name返回该类型在自身包内的类型名，如果是未命名类型会返回""
    Name() string
    // PkgPath返回类型的包路径，即明确指定包的import路径，如"encoding/base64"
    // 如果类型为内建类型(string, error)或未命名类型(*T, struct{}, []int)，会返回""
    PkgPath() string
    // 返回类型的字符串表示。该字符串可能会使用短包名（如用base64代替"encoding/base64"）
    // 也不保证每个类型的字符串表示不同。如果要比较两个类型是否相等，请直接用Type类型比较。
    String() string
    // 返回要保存一个该类型的值需要多少字节；类似unsafe.Sizeof
    Size() uintptr
    // 返回当从内存中申请一个该类型值时，会对齐的字节数
    Align() int
    // 返回当该类型作为结构体的字段时，会对齐的字节数
    FieldAlign() int
    // 如果该类型实现了u代表的接口，会返回真
    Implements(u Type) bool
    // 如果该类型的值可以直接赋值给u代表的类型，返回真
    AssignableTo(u Type) bool
    // 如该类型的值可以转换为u代表的类型，返回真
    ConvertibleTo(u Type) bool
    // 返回该类型的字位数。如果该类型的Kind不是Int、Uint、Float或Complex，会panic
    Bits() int
    // 返回array类型的长度，如非数组类型将panic
    Len() int
    // 返回该类型的元素类型，如果该类型的Kind不是Array、Chan、Map、Ptr或Slice，会panic
    Elem() Type
    // 返回map类型的键的类型。如非映射类型将panic
    Key() Type
    // 返回一个channel类型的方向，如非通道类型将会panic
    ChanDir() ChanDir
    // 返回struct类型的字段数（匿名字段算作一个字段），如非结构体类型将panic
    NumField() int
    // 返回struct类型的第i个字段的类型，如非结构体或者i不在[0, NumField())内将会panic
    Field(i int) StructField
    // 返回索引序列指定的嵌套字段的类型，
    // 等价于用索引中每个值链式调用本方法，如非结构体将会panic
    FieldByIndex(index []int) StructField
    // 返回该类型名为name的字段（会查找匿名字段及其子字段），
    // 布尔值说明是否找到，如非结构体将panic
    FieldByName(name string) (StructField, bool)
    // 返回该类型第一个字段名满足函数match的字段，布尔值说明是否找到，如非结构体将会panic
    FieldByNameFunc(match func(string) bool) (StructField, bool)
    // 如果函数类型的最后一个输入参数是"..."形式的参数，IsVariadic返回真
    // 如果这样，t.In(t.NumIn() - 1)返回参数的隐式的实际类型（声明类型的切片）
    // 如非函数类型将panic
    IsVariadic() bool
    // 返回func类型的参数个数，如果不是函数，将会panic
    NumIn() int
    // 返回func类型的第i个参数的类型，如非函数或者i不在[0, NumIn())内将会panic
    In(i int) Type
    // 返回func类型的返回值个数，如果不是函数，将会panic
    NumOut() int
    // 返回func类型的第i个返回值的类型，如非函数或者i不在[0, NumOut())内将会panic
    Out(i int) Type
    // 返回该类型的方法集中方法的数目
    // 匿名字段的方法会被计算；主体类型的方法会屏蔽匿名字段的同名方法；
    // 匿名字段导致的歧义方法会滤除
    NumMethod() int
    // 返回该类型方法集中的第i个方法，i不在[0, NumMethod())范围内时，将导致panic
    // 对非接口类型T或*T，返回值的Type字段和Func字段描述方法的未绑定函数状态
    // 对接口类型，返回值的Type字段描述方法的签名，Func字段为nil
    Method(int) Method
    // 根据方法名返回该类型方法集中的方法，使用一个布尔值说明是否发现该方法
    // 对非接口类型T或*T，返回值的Type字段和Func字段描述方法的未绑定函数状态
    // 对接口类型，返回值的Type字段描述方法的签名，Func字段为nil
    MethodByName(string) (Method, bool)
    // 内含隐藏或非导出方法
}

通过反射我们可以拿到reflect.Type类型(reflect.TypeOf(v))

//官网relect的Value 
type Value struct {
    // 内含隐藏或非导出字段
}

通过反射我们可以拿到reflect.Value类型(reflect.ValueOf(v))

反射的相关函数和转换

//专门用于做反射
func test(b interface{}){
	//1.如何将interface{}转成reflect.value
	rVal := reflect.ValueOf(b)

	//2.将reflect.value转成interface{}
	iVal := rVal.Interface()

	//3. 如何将interface转成原来的变量类型(使用类型断言)
	v := iVal.(Stu)

}

反射的快速入门

对(基本数据类型,interface{},reflect.Value)进行反射的基本操作

package main

import (
	"fmt"
	"reflect"
)

func ReflectTest01(b interface{}){
	//通过反射获取传入的type(类型),kind(类别),值
	//先获取到reflect.Type
	rTyp := reflect.TypeOf(b)
	fmt.Println("rType=",rTyp)//返回显示虽然是int，实际上是reflect.Type类型
	//2.获取到reflect.Value
	rVal := reflect.ValueOf(b)
	fmt.Printf("rValue=%v,type=%T\n",rVal,rVal)//返回显示虽然是100，实际上是reflect.Value类型
	fmt.Printf("真正的值=%v,type=%T\n",rVal.Int(),rVal.Int())

	//将rVal转成interface{}
	iV := rVal.Interface()
	//将interface{}经过断言转成需要的类型
	num := iV.(int)
	fmt.Println("num=",num)
}

func main(){
	//1.先定义一个int
	var num int = 100
	ReflectTest01(num)

}

对(结构体,interface{},reflect.Value)进行反射的基本操作

package main

import (
	"fmt"
	"reflect"
)

type Stu struct{
	Name string
	Age int
}

func ReflectTest02(b interface{}){
	//通过反射获取传入的type(类型),kind(类别),值
	//先获取到reflect.Type
	rTyp := reflect.TypeOf(b)
	fmt.Println("rType=",rTyp)//实际上是reflect.Type类型
	//2.获取到reflect.Value
	rVal := reflect.ValueOf(b)
	fmt.Printf("rValue=%v,type=%T\n",rVal,rVal)//实际上是reflect.Value类型

	//将rVal转成interface{}
	iV := rVal.Interface()
	//将interface{}经过断言转成需要的类型
	fmt.Printf("iV=%v,type=%T\n",iV,iV)//iV={admin 20},type=main.Stu
}

func main(){
	//1.先定义一个Stu实例对象
	stu := Stu{
		Name: "admin",
		Age: 20,
	}
	ReflectTest02(stu)
}

获取kind(类别)

//先获取到reflect.Type
rTyp := reflect.TypeOf(b)
fmt.Println("rType=",rTyp)//实际上是reflect.Type类型
//2.获取到reflect.Value
rVal := reflect.ValueOf(b)
fmt.Printf("rValue=%v,type=%T\n",rVal,rVal)//实际上是reflect.Value类型
//3.获取变量对应的kind()
	
kind1 := rTyp.Kind()
kind2 := rVal.Kind()
fmt.Printf("rType kind=%v,rVal kind=%v\n",kind1,kind2)

常量

  • 常量使用const
  • 常量在定义的时候，必须初始化
  • 常量不能修改
  • 常量只能修饰bool、数值类型(int,float系列)、string类型
  • 语法:const 常量名 [type] = value 
const (
  a = iota //表示给a赋值一个0
  b
  c
)

反射注意事项和细节

  1. reflect.Value.Kind,获取变量的类别，返回的是一个常量(看手册)
  2. Type是类型，Kind是类别，Type和Kind可能是相同的，也可以是不同的
  • 比如: var num int = 10 num的Type是int,Kind也是int
  • 比如: var stu Stustu的Type是包名.Stu,Kind是struct
  1. 通过反射可以让变量在interface{}和reflect.Value之间相互转换
变量<---------->interface{}<------------->reflect.Value

  1. 使用反射的方式获取变量的值(并返回对应的类型)要求数据类型匹配，比如x是int，那么就应该reflect.ValueOf(x).Int(),而不能使用其他的，否则回报panic;结构体要类型断言

  2. 通过反射的来修改变量，注意当使用SetXxx方法来设置需要通过的对应的指针类型来完成，这样才能修改传入的变量的值，同时需要使用到reflect.Va;ueOf().Elem()方法

问题

//通过反射修改num int的值&修改student的值
func reflect01(b interface{}){
  rVal := reflect.ValueOf(b)
  rVal.SetSInt(20)
}

func main(){
	var num int = 10
	reflect01(&num)//num:这样传入num值不会改变，所以传入num地址
}

go--反射&常量

其实reflect.ValueOf()返回的类型是一个指针

go--反射&常量go--反射&常量

问题解决
go--反射&常量

reflect.ValueOf(interface{}).Elem().SetInt(value)

//通过反射修改num int的值&修改student的值
func reflect01(b interface{}){
  rVal := reflect.ValueOf(b)
  rVal.Elem().SetInt(20)
}

func main(){
	var num int = 10
	reflect01(&num)//num:这样传入num值不会改变，所以传入num地址
	fmt.Println("num = ",num)
}

go--反射&常量

  1. 怎么理解reflect.ValueOf(interface{}).Elem().SetInt(value) 
/*
func main(){
  var num = 10
  var b *int = &num
  *b = 3
}
*/
func main(){
var num int = 100
fn := reflect.ValueOf(&num)
fn.Elem().SetInt(200)
}

反射最佳实践

  1. 使用反射来遍历结构体的字段，调用结构体的方法，并获取结构体标签的值
    go--反射&常量
    go--反射&常量

获取reflect.Type类型

reflect.TypeOf(interface{})

获取reflect.Value类型

reflect.ValueOf(interface{})

获取到对应的类别

reflect.ValueOf(interface{}).Kind()

获取结构体有几个字段

reflect.ValueOf(interface{}).NumField()

获取结构体字段

reflect.ValueOf(interface{}).Field()

获取struct标签，需要通过reflect.Type来获取tag标签的值

reflect.TypeOf(interface{}).Field(number).Tag.Get("json")

获取结构体有多少个方法

reflect.ValueOf(interface{}).NumMethod()

调用方法

//reflect.ValueOf(interface{}).Method(num): 获取到结构体的第几个方法,初始值是0开始(0是第一个,1是第二个...)
//Call(nil):传输的值是空
//方法的排序默认是按照函数名排序(ASCII码的大小排序)
reflect.ValueOf(interface{}).Method(num).Call(nil)

go--反射&常量

反射方法原则

在进行方法排序的时候，是按照函数的名字进行排序（先比较ascii码）

Print()//2
GetSum()//1
Set()//3

反射操作结构体类型

type User struct{
  Uid string
  Name string
}
func TestReflectStruct(t *testing.T){
  var (
    model *User
    st   reflect.Type
    elem reflect.Value
  )
  st = reflect.TypeOf(model)//获取类型*User
  t.Log(st.Kind().String()) //ptr
  st = st.Elem()//指向的类型
  t.Log(st.Kind().String()) //struct
  elem = reflect.New(st) //New返回一个Value类型的值，类似于java底层的new
  model = elem.Interface().(*User)//转成interface{}类型后通过类型断言重新变成*User
  elem = elem.Elem()//取得elem指向的值
  elem.FeildByName("Uid").SetString("value")//赋值
  elem.FeildByName("Name").SetString("value")
}
标签：

相关文章