GoLang之图解反射

GoLang之图解反射

注：本文基于Windos系统上Go SDK v1.18进行讲解

1.前言

用到反射的场景不外乎是变量类型不确定，内部结构不明朗的情况，所以反射的作用简单来说就是把类型元数据暴露给用户使用。
我们已经介绍过runtime包中_type、uncommontype、eface、iface等类型了，reflect也要和它们打交道，但是它们都属于未导出类型，所以reflect在自己的包中又定义了一套，两边的类型定义是保持一致的。

reflect中有两个核心类型，reflect.Type和reflect.Value，它们两个撑起了反射功能的基本框架。

2.Type

reflect.Type是一个接口类型，它定义了一系列方法用于获取类型各方面的信息。

//reflect/type.go
type Type interface {
    //以下是所有kind通用的方法
	Align() int //对齐边界
    FieldAlign() int //作为结构体字段的对齐边界
    Method(int) Method //获取方法数组中第i个Method
    MethodByName(string) (Method, bool) //按照名称查找方法
    NumMethod() int //方法列表中可导出方法的数目
    Name() string //类型名称
    PkgPath() string //包路径
    Size() uintptr //该类型变量占用字节数
    String() string //获取类型的字符串表示
    Kind() Kind //类型对应的reflect.Kind
    Implements(u Type) bool //该类型是否实现了接口u
    AssignableTo(u Type) bool //是否可以赋值给类型u
    ConvertibleTo(u Type) bool //是否可转换为类型u
    Comparable() bool //是否可比较

	//以下是某些Kind的方法
	//Int*, Uint*, Float*, Complex*: 
	Bits() int
    //Array,Ptr,Slice,Map: 
    Elem() Type
    //Array
    Len() int
    //Chan:ChanDir, Elem 
    ChanDir() ChanDir
    //Func: 
    In(i int) Type
    NumIn() int
    Out(i int) Type
    NumOut() int
    IsVariadic() bool
    //Map: 
    Key() Type
	//Struct: 
    Field(i int) StructField
    FieldByIndex(index []int) StructField
    FieldByName(name string) (StructField, bool)
    FieldByNameFunc(match func(string) bool) (StructField, bool)  
    NumField() int
	
	common() *rtype
	uncommon() *uncommonType
}

通常会用reflect.TypeOf这个函数来拿到一个reflect.Type类型的返回值。
它接收一个空接口类型的参数，在这里我们要插播一个之前介绍空接口时忽略的知识点，和给空接口类型的参数赋值有关。

//reflect/type.go
func TypeOf(i any) Type {
	eface := *(*emptyInterface)(unsafe.Pointer(&i))
	return toType(eface.typ)
}

//builtin/builtin.go
type any = interface{}

//reflect/type.go
func toType(t *rtype) Type {
	if t == nil {
		return nil
	}
	return t
}

假设我们要反射一个字符串类型的变量a：

a := "eggo"
t := reflect.TypeOf(a)

我们知道空接口类型的变量中会保存一个数据地址，那上面这个例子中reflect.TypeOf接收的参数是下面这样的吗？

答案是否定的，原因是这样并不符合“Go语言中传参值拷贝”的语义。先不论其它，单看reflect.TypeOf(a)这个函数调用，从语义上讲也应该使用a的拷贝值，而不是直接使用a。但问题是空接口类型的参数需要的只是一个数据指针，不能拷贝a的值过来，又不能拷贝a的地址过来，那拷贝谁？

解决这个问题的方式，是在编译阶段增加临时变量作为a的拷贝值(copy of a)，再把copy of a的地址传给函数使用，无论reflect.TypeOf对参数指向的数据做什么修改，都不会作用到变量a身上。这样就通过传递复制后的地址实现了传值的语义。
copy of a的地址会在编译阶段转换为空接口类型，所以TypeOf接收到的参数就如下图所示。

接下来，reflect.TypeOf函数会把runtime.eface类型的参数i转换成reflect.emptyInterface类型并赋给局部变量eface。

因为*rtype实现了reflect.Type接口，所以只要把eface这里的typ字段取出来，包装成reflect.Type类型的返回值就好了。
这就相当于下面这样把eface.typ赋值给一个reflect.Type类型的变量，这两行代码可以帮助我们理解返回值的结构。

var ret reflect.Type
ret = eface.typ

还记得非空接口长什么样子吧？eface.typ是个指针，所以这个返回值的data字段就等于eface.typ，也就是string类型的元数据地址，而itab中的接口类型就是reflect.Type，动态类型就是*rtype。

至于*rtype实现的这些接口要求的方法，也总不过是去data字段指向的类型元数据那里获取各种信息罢了。
例如可以使用Implements方法来判断类型是否实现了某个接口，比方说fmt.Stringer接口。

//fmt/print.go
type Stringer interface {
    String() string
}

判断的过程就是通过类型元数据找到方法元数据数组，这里的Method是按照方法名称排过序的，所以只要和接口要求的方法列表两相比较一下，就可以确定该类型是否实现指定接口了。
这就是reflect的Type类型和TypeOf方法，重点是要理解反射如何拿到反射变量的类型元数据，剩下的就好说了。

附：

    var i interface{}
	a := 1
	i = a
	fmt.Println(a) //1
	fmt.Println(i) //1
	i = 5
	fmt.Println(a) //1
	fmt.Println(i) //5

    var i interface{}
	a := 1
	i = a
	fmt.Println(a) //1
	fmt.Println(i) //1
	a = 9
	fmt.Println(a) //9
	fmt.Println(i) //1

    var ii interface{}
	aa := []int{1, 2, 3}
	ii = aa
	fmt.Println(ii) //[1 2 3]
	fmt.Println(aa) //[1 2 3]
	aa[1] = 5
	fmt.Println(ii) //[1 5 3]
	fmt.Println(aa) //[1 5 3]

3.Value

与reflect.Type不同，reflect.Value是一个结构体类型。
1.typ存储反射变量的类型元数据指针；
2.ptr存储数据地址；
3.flag是一个位标识符，存储反射变量值的一些描述信息，例如类型掩码，是否为指针，是否为方法，是否只读等等。

//reflect/value.go
type Value struct {
    typ *rtype
    ptr unsafe.Pointer
    flag
}

//reflect/type.go
 type rtype struct {
	size       uintptr
	ptrdata    uintptr // number of bytes in the type that can contain pointers
	hash       uint32  // hash of type; avoids computation in hash tables
	tflag      tflag   // extra type information flags
	align      uint8   // alignment of variable with this type
	fieldAlign uint8   // alignment of struct field with this type
	kind       uint8   // enumeration for C
	// function for comparing objects of this type
	// (ptr to object A, ptr to object B) -> ==?
	equal     func(unsafe.Pointer, unsafe.Pointer) bool
	gcdata    *byte   // garbage collection data
	str       nameOff // string form
	ptrToThis typeOff // type for pointer to this type, may be zero
}

reflect.Value同样提供了很多方法，这里我们只关注利用反射来更新变量值的过程。

func main() {
	a := "eggo"
	v := reflect.ValueOf(a)
	v.SetString("new eggo") //panic: reflect: reflect.Value.SetString using unaddressable value     运行错误
	println(a)
}

首先要注意，reflect.ValueOf函数的参数也是空接口类型，所以和前面介绍的TypeOf一样，它接收到的参数中数据指针同样指向a的一个拷贝值。

//reflect/value.go
func ValueOf(i any) Value {
    if i == nil {
        return Value{}
    }

    escapes(i)
    return unpackEface(i)
}

此外还要注意，reflect.ValueOf函数目前的实现方式，会通过escapes函数显示地把参数i指向的变量逃逸到堆上。
对应到上面这个例子，copy of a就会逃逸到堆上，栈上存储它的地址。所以这个空接口类型的参数i，其动态类型指向string类型元数据，动态值指向堆上的copy of a。

ValueOf函数的返回值是reflect.Value类型，其typ字段取参数的_type字段，指向string类型元数据，ptr字段取参数的data字段，指向copy of a。

接下来，这个返回值被赋给局部变量v，调用v.SetString时，方法接收者v作为第一个参数，字符串"new eggo"作为第二个参数。 因为此时v.ptr指向的是copy of a，而不是a，所以是不允许修改的。

因为修改这样一个用户都不知道的临时变量copy of a没有任何意义，毕竟通过反射来修改变量值本意是要作用到原变量身上的，所以上面这个例子在执行阶段会发生panic：

panic: reflect: reflect.Value.SetString using unaddressable value

这个异常信息就是提醒我们此时反射修改值的行为并不符合预期。若想顺利修改变量a，就需要反射a的指针。

func main() {
	a := "eggo"
	v := reflect.ValueOf(&a)
	v.Elem().SetString("new eggo")
	println(a) //new eggo
}

传参依然是值拷贝，只不过这一次拷贝的是a的地址，所以reflect.ValueOf会显示地把局部变量a逃逸到堆上，栈上只存它的地址&a。

局部变量v中，v.typ指向*string类型元数据，v.ptr等于a的地址。

通过v.Elem()的返回值再调用SetString方法时，修改的就是原来的变量a了。

通过反射修改变量值的问题有点绕，但是只要记住函数传参值拷贝，以及反射修改变量值要作用到原变量身上才有意义这两个原则，再梳理出Value对象内部结构，理解起来就没那么困难了。
关于反射我们就介绍这些，理解反射的基础还是类型系统和接口，反射的所有功能都没有脱离这两个知识点。