第十二章反射

Go语言提供了一种机制，在编译时不知道类型的情况下，可更新变量、在运行时查看值、调用方法以及直接对它们的布局进行操作，这种机制称为反射（reflection）

• 为什么使用反射
• reflect.Type和reflect.Value

反射功能由reflect包提供，它定义了两个重要的类型：Type和Value。Type表示Go语言的一个类型，它是一个有很多方法的接口，这些方法可以用来识别类型以及透视类型的组成部分，比如一个结构的各个字段或者一个函数的各个参数。reflect.Type接口只有一个实现，即类型描述符，接口值中的动态类型也是类型描述符

7.5-->接口值：一个接口类型的值有两个部分：一个具体类型和该类型的一个值，二者称为接口的动态类型和动态值。对于像Go这样的静态类型语言，类型仅仅是一个编译时的概念，所以类型不是一个值。在我们的概念模型中，用类型描述符来提供每个类型的具体信息，比如它的名字和方法。对于一个接口值，类型部分就用对应的类型描述符来表述

reflect.TypeOf函数接受任何的interface{}参数，并且把接口中的动态类型以reflect.Type形式返回

t := reflect.TypeOf(3)

fmt.Println(t.String())//"int"

fmt.Println(t)//"int"

把一个具体值赋给一个接口类型时会发生一个隐式类型转换，转换会生成一个包含两部分内容的接口值：动态类型部分是操作数的类型（int），动态值部分是操作数的值（3）

因为reflect.TypeOf返回一个接口值对应的动态类型，所以它返回总是具体类型（而不是接口类型）

reflect.Type满足fmt.Stringer。因为输出一个接口值的动态类型在调试和日志中很常用，所以fmt.Printf提供了一个简写方式%T，内部实现就使用了reflect.TypeOf

reflect包的另一个重要类型就是value。reflect.Value可以包含一个任意类型的值

reflect.ValueOf函数接受任意的interface{}并将接口的动态值以reflect.Value的形式返回。与reflect.TypeOf类似，reflect.ValueOf的返回值也都是具体值，不过reflect.Value也可以包含一个接口值

reflect.ValueOf的逆操作是reflect.Value.Interface方法，它返回一个interface{}接口，与reflect.Value包含同一个具体值

reflect.TypeOf返回类型（reflect.Type）

reflect.ValueOf返回值（reflect.Value）

可以从reflect.Value获得类型

通过kind来判断类型

package format

import (
    "reflect"
    "strconv"
)

//Any把任何值格式化为一个字符串
func Any(value interface{}) string {
    return formatAtom(reflect.ValueOf(value))
}

//formatAtom格式化一个值，且不分析它的内部结构
func formatAtom(v reflect.Value) string {
    switch v.Kind() {
    case reflect.Invalid:
        return "invalid"
    case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
        return strconv.FormatInt(v.Int(), 10)
    case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64,reflect.Uintptr:
        return strconv.FormatUint(v.Uint(), 10)
    case reflect.Bool:
        return strconv.FormatBool(v.Bool())
    case reflect.String:
        return strconv.Quote(v.String())
    case reflect.Chan, reflect.Func, reflect.Ptr, reflect.Slice, reflect.Map:
        return v.Type().String() + "0x" +
            strconv.FormatUint(uint64(v.Pointer()), 16)
    default:
        return v.Type().String() + "value"
    }
}

• Display：一个递归的值显示器

Display函数对给定的任意一个复杂值x，输出这个复杂值的完整结构，并对找到的每个元素标上这个元素的路径

func Dispaly(name string, x interface{}) {
    fmt.Printf("Display %s (%T):\n", name, x)
    display(name, reflect.ValueOf(x))
}

在display中，我们使用之前定义的formatAtom函数来输出基础值（基础类型、函数和通道），使用reflect.Value的一些方法来递归展示复杂类型的每个组成部分。当递归深入时，path字符串会增长，以表示如何找到当前值

func display(path string, v reflect.Value) {
    switch v.Kind() {
    case reflect.Invalid:
        fmt.Println("%s = invalid\n", path)
    case reflect.Slice, reflect.Array:
        for i := 0; i < v.Len(); i++ {
            display(fmt.Sprintf("%s[%d]", path, i), v.Index(i))
        }
    }
}

• 示例：编码S表达式
• 使用reflect.Value来设置值

反射如何改变值？

一个变量是一个可寻址的存储区域，其中包含了一个值，并且它的值可以通过这个地址来更新

通过reflect.ValueOf(x)返回的reflect.Value都是不可寻址的

调用reflect.ValueOf(&x).Elem()可以获得任意变量x可寻址的Value值

可以通过变量的CanAddr方法来询问reflect.Value变量是否可寻址

可以通过一个指针来间接获取一个可寻址的reflect.Value，即使这个指针是不可寻址的

从一个可寻址的reflect.Value()获取变量需要三步

首先，调用Addr()，返回一个Value，其中包含一个指向变量的指针

接下来，在这个Value上调用Interface()，会返回一个包含这个指针的interface{}值

最后，如果知道变量的类型，可以使用类型断言来把接口内容转换为一个普通指针

之后就可以通过这个指针来更新变量

还可以直接通过可寻址的reflect.Value来更新变量，不用通过指针，而是直接调用reflect.Value.Set方法

• 示例：解码S表达式
• 访问结构体字段标签
• 显示类型的方法
• 注意事项

第十二章反射

原文：https://www.cnblogs.com/liushoudong/p/13086844.html