golang 中有关reflect的一些使用总结

2019-11-04 编程 Golang 0 评论

go 中 reflect 基本介绍 & 一些使用技巧

反射中几个注意事项

反射包中主要的三个类型：Type（类型），Value，Kind（类别）

Type & Kind 的区别主要是：

type Foo struct {
	A int 
	B string
}

func main() {
	test := Foo{}
	fmt.Println(reflect.TypeOf(test))  
    fmt.Println(reflect.TypeOf(test).Kind())
}

// 输出结果为
// Type :  main.Foo
// Kind :  struct

reflect 中的 Type

Type 的本质就是一个 interface

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)
    // 内含隐藏或非导出方法
}

下面这段代码主要演示了 Implements & ConvertibleTo 接口，这两个接口我觉得比较重要

判断某个 struct 是否实现了某个接口

package main

import (
	"fmt"
	"reflect"
)

// test interface
type TestInterface interface {
	aa()
}

// test struct
type TestStruct struct {
}

func (t *TestStruct) aa() {}

// 可以学习一下，如何获得 struct / interface 的 Type
var TestStructName = reflect.TypeOf((*TestStruct)(nil)).Elem()
var TestInterfaceName = reflect.TypeOf((*TestInterface)(nil)).Elem()

func main() {
	fmt.Println(TestInterfaceName, TestStructName)

	a := TestStruct{}
	ptrType := reflect.TypeOf(&a)
	t := reflect.TypeOf(a)

	fmt.Println(ptrType.Implements(TestInterfaceName))
	fmt.Println(t.ConvertibleTo(TestStructName))
}

reflect 中的 Value

reflect.Value 的主要作用就是读取，设置或创建值
首先，需要使用 refVal := reflect.ValueOf(var) 为变量创建一个 reflect.Value 实例。如果希望能够使用反射来修改值，则必须使用 refPtrVal := reflect.ValueOf(＆var); 获得指向变量的指针。如果不这样做，则可以使用反射来读取该值，但不能对其进行修改。
一旦有了 reflect.Value 实例就可以使用 Type() 方法获取变量的 reflect.Type。
如果要修改值，请记住它必须是一个指针，并且必须首先对其进行解引用。使用 refPtrVal.Elem().Set(newRefVal) 来修改值，并且传递给 Set() 的值也必须是 reflect.Value。
如果要创建一个新值，可以使用函数 newPtrVal := reflect.New(varType) 来实现，并传入一个 reflect.Type。这将返回一个指针值，然后可以像上面那样使用 Elem().Set() 对其进行修改。
最后，你可以通过调用 Interface() 方法从 reflect.Value 回到普通变量值。由于 Go 没有泛型，因此变量的原始类型会丢失；该方法返回类型为 interface{} 的值。如果创建了一个指针以便可以修改该值，则需要使用 Elem().Interface() 解引用反射的指针。在这两种情况下，都需要将空接口转换为实际类型才能使用它。

type Foo struct {
    A int `tag1:"First Tag" tag2:"Second Tag"`
    B string
}

func main() {
    greeting := "hello"
    f := Foo{A: 10, B: "Salutations"}

    gVal := reflect.ValueOf(greeting)
    // not a pointer so all we can do is read it
    fmt.Println(gVal.Interface())

    gpVal := reflect.ValueOf(&greeting)
    // it’s a pointer, so we can change it, and it changes the underlying variable
    gpVal.Elem().SetString("goodbye")
    fmt.Println(greeting)

    fType := reflect.TypeOf(f)
    fVal := reflect.New(fType)
    fVal.Elem().Field(0).SetInt(20)
    fVal.Elem().Field(1).SetString("Greetings")
    f2 := fVal.Elem().Interface().(Foo)
    fmt.Printf("%+v, %d, %s\n", f2, f2.A, f2.B)
}

输出结果如下所示：

1
2
3

hello
goodbye
{A:20 B:Greetings}, 20, Greetings

反射创建引用类型的实例

除了生成内置类型和用户定义类型的实例之外，还可以使用反射来生成通常需要 make 函数的实例。可以使用 reflect.MakeSlice，reflect.MakeMap 和 reflect.MakeChan 函数制作切片，Map 或通道。在所有情况下，都提供一个 reflect.Type，然后获取一个 reflect.Value，可以使用反射对其进行操作，或者可以将其分配回一个标准变量。

func main() {
  // 定义变量
    intSlice := make([]int, 0)
    mapStringInt := make(map[string]int)

  // 获取变量的 reflect.Type
    sliceType := reflect.TypeOf(intSlice)
    mapType := reflect.TypeOf(mapStringInt)

    // 使用反射创建类型的新实例
    intSliceReflect := reflect.MakeSlice(sliceType, 0, 0)
    mapReflect := reflect.MakeMap(mapType)

    // 将创建的新实例分配回一个标准变量
    v := 10
    rv := reflect.ValueOf(v)
    intSliceReflect = reflect.Append(intSliceReflect, rv)
    intSlice2 := intSliceReflect.Interface().([]int)
    fmt.Println(intSlice2)

    k := "hello"
    rk := reflect.ValueOf(k)
    mapReflect.SetMapIndex(rk, rv)
    mapStringInt2 := mapReflect.Interface().(map[string]int)
    fmt.Println(mapStringInt2)
}

本文链接： https://overtalk.site/2019/11/04/go-reflect/

版权声明： 本博客所有文章除特别声明外，均采用 CC BY 4.0 CN协议许可协议。转载请注明出处！

QinHanGame Developer & Designer

当你发现自己的才华撑不起野心时，就请安静下来学习吧！