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

  1. 反射中几个注意事项
    1. reflect 中的 Type
    2. reflect 中的 Value
      1. 反射创建引用类型的实例

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

反射中几个注意事项

  • 反射包中主要的三个类型:Type(类型),Value,Kind(类别)
  • Type & Kind 的区别主要是:
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    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
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    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 接口,这两个接口我觉得比较重要
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    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() 解引用反射的指针。在这两种情况下,都需要将空接口转换为实际类型才能使用它。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
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,可以使用反射对其进行操作,或者可以将其分配回一个标准变量。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
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)
}

欢迎指出任何有错误或不够清晰的表达。可以在下面评论区评论,也可以邮件至 qinhan_shu@163.com

文章标题:golang 中有关reflect的一些使用总结

本文作者:QinHan

发布时间:2019-11-04, 17:06:04

最后更新:2020-02-20, 05:42:12

原始链接:https://qinhan.site/2019/11/04/go-reflect/

版权声明: "署名-非商用-相同方式共享 4.0" 转载请保留原文链接及作者。

目录
×

喜欢就点赞,疼爱就打赏