引言

计算中的反射是指程序能够检查自身结构的能力，特别是通过类型；它是一种元编程形式。它也是一个主要的混淆来源。

在本文中，我们试图通过解释反射在 Go 中的工作原理来澄清问题。每种语言的反射模型都不同（许多语言根本不支持反射），但本文是关于 Go 的，因此在本文的其余部分中，“反射”一词应理解为“Go 中的反射”。

2022年1月补充说明：这篇博文写于2011年，早于 Go 中的参数多态（又名泛型）。尽管该语言的这一发展并没有使文章中的任何重要内容变得不正确，但为了避免混淆熟悉现代 Go 的人，文章在一些地方进行了调整。

类型和接口

因为反射建立在类型系统之上，所以我们从回顾 Go 中的类型开始。

Go 是静态类型的。每个变量都有一个静态类型，即在编译时已知并固定的一种类型：int、float32、*MyType、[]byte 等。如果声明

type MyInt int

var i int
var j MyInt

那么 i 的类型是 int，j 的类型是 MyInt。变量 i 和 j 具有不同的静态类型，尽管它们具有相同的底层类型，但在没有转换的情况下不能相互赋值。

一类重要的类型是接口类型，它表示固定的方法集。（在讨论反射时，我们可以忽略接口定义在多态代码中作为约束的使用。）接口变量可以存储任何具体（非接口）值，只要该值实现了接口的方法。一个著名的例子是 io.Reader 和 io.Writer，来自 io 包 的 Reader 和 Writer 类型。

// Reader is the interface that wraps the basic Read method.
type Reader interface {
    Read(p []byte) (n int, err error)
}

// Writer is the interface that wraps the basic Write method.
type Writer interface {
    Write(p []byte) (n int, err error)
}

任何实现了具有此签名的 Read（或 Write）方法的类型都被认为实现了 io.Reader（或 io.Writer）。出于本文讨论的目的，这意味着类型为 io.Reader 的变量可以持有任何其类型具有 Read 方法的值。

var r io.Reader
r = os.Stdin
r = bufio.NewReader(r)
r = new(bytes.Buffer)
// and so on

重要的是要明确，无论 r 可能持有何种具体值，r 的类型始终是 io.Reader：Go 是静态类型的，r 的静态类型是 io.Reader。

一个非常重要的接口类型示例是空接口

interface{}

或其等价别名，

any

它表示空方法集，任何值都满足它，因为每个值都具有零个或更多方法。

有些人说 Go 的接口是动态类型的，但这具有误导性。它们是静态类型的：接口类型的变量总是具有相同的静态类型，即使在运行时存储在接口变量中的值可能会改变类型，该值也始终会满足该接口。

我们需要精确地说明所有这些，因为反射和接口密切相关。

接口的表示

Russ Cox 写了一篇 详细的博客文章，介绍了 Go 中接口值的表示。此处无需重复完整的故事，但有必要进行一个简化的总结。

接口类型的变量存储一对：赋给变量的具体值及其类型描述符。更精确地说，该值是实现接口的底层具体数据项，类型描述了该项的完整类型。例如，在

var r io.Reader
tty, err := os.OpenFile("/dev/tty", os.O_RDWR, 0)
if err != nil {
    return nil, err
}
r = tty

之后，r 示意性地包含 (值, 类型) 对，(tty, *os.File)。请注意，类型 *os.File 实现了除 Read 之外的其他方法；尽管接口值只提供了对 Read 方法的访问，但内部的值携带了关于该值的所有类型信息。这就是为什么我们可以做这样的事情

var w io.Writer
w = r.(io.Writer)

此赋值中的表达式是类型断言；它断言的是 r 内部的项也实现了 io.Writer，因此我们可以将其赋值给 w。赋值后，w 将包含对 (tty, *os.File)。这与 r 中持有的对相同。接口的静态类型决定了可以使用接口变量调用哪些方法，即使内部的具体值可能具有更大的方法集。

继续，我们可以这样做

var empty interface{}
empty = w

我们的空接口值 empty 将再次包含相同的对，(tty, *os.File)。这很方便：空接口可以保存任何值，并包含我们可能需要的所有关于该值的信息。

（我们在这里不需要类型断言，因为静态已知 w 满足空接口。在我们将值从 Reader 移动到 Writer 的示例中，我们需要明确并使用类型断言，因为 Writer 的方法不是 Reader 方法的子集。）

一个重要的细节是，接口变量内部的对总是具有 (值, 具体类型) 的形式，不能具有 (值, 接口类型) 的形式。接口不持有接口值。

现在我们准备好进行反射了。

反射的第一定律

1. 反射从接口值到反射对象。

在基本层面，反射只是一种检查存储在接口变量中的类型和值对的机制。首先，我们需要了解 reflect 包 中的两种类型：Type 和 Value。这两种类型提供了对接口变量内容的访问，两个简单的函数，称为 reflect.TypeOf 和 reflect.ValueOf，从接口值中检索 reflect.Type 和 reflect.Value 片段。（此外，从 reflect.Value 很容易获取相应的 reflect.Type，但我们现在将 Value 和 Type 概念分开。）

让我们从 TypeOf 开始

package main

import (
    "fmt"
    "reflect"
)

func main() {
    var x float64 = 3.4
    fmt.Println("type:", reflect.TypeOf(x))
}

这个程序打印

type: float64

你可能会想这里哪里有接口，因为程序看起来像是将 float64 变量 x 传递给 reflect.TypeOf，而不是接口值。但它在那里；正如 godoc 报告，reflect.TypeOf 的签名包含一个空接口

// TypeOf returns the reflection Type of the value in the interface{}.
func TypeOf(i interface{}) Type

当我们调用 reflect.TypeOf(x) 时，x 首先被存储在一个空接口中，然后作为参数传递；reflect.TypeOf 解包该空接口以恢复类型信息。

reflect.ValueOf 函数当然会恢复值（从现在开始我们将省略样板代码，只关注可执行代码）

var x float64 = 3.4
fmt.Println("value:", reflect.ValueOf(x).String())

打印

value: <float64 Value>

（我们显式调用 String 方法，因为默认情况下 fmt 包会深入到 reflect.Value 中显示内部的具体值。而 String 方法不会。）

reflect.Type 和 reflect.Value 都有许多方法，允许我们检查和操作它们。一个重要的例子是 Value 有一个 Type 方法，返回 reflect.Value 的 Type。另一个是 Type 和 Value 都有一个 Kind 方法，返回一个常量，指示存储的项目类型：Uint、Float64、Slice 等。此外，Value 上的方法（如 Int 和 Float）允许我们获取存储在其中的值（作为 int64 和 float64）

var x float64 = 3.4
v := reflect.ValueOf(x)
fmt.Println("type:", v.Type())
fmt.Println("kind is float64:", v.Kind() == reflect.Float64)
fmt.Println("value:", v.Float())

打印

type: float64
kind is float64: true
value: 3.4

还有像 SetInt 和 SetFloat 这样的方法，但要使用它们，我们需要理解可设置性，这是反射第三定律的主题，下面将讨论。

反射库有一些值得单独指出的特性。首先，为了保持 API 简单，Value 的“getter”和“setter”方法对可以容纳该值的最大类型进行操作：例如，所有有符号整数都是 int64。也就是说，Value 的 Int 方法返回一个 int64，而 SetInt 值接受一个 int64；可能需要转换为实际涉及的类型

var x uint8 = 'x'
v := reflect.ValueOf(x)
fmt.Println("type:", v.Type())                            // uint8.
fmt.Println("kind is uint8: ", v.Kind() == reflect.Uint8) // true.
x = uint8(v.Uint())                                       // v.Uint returns a uint64.

第二个特性是，反射对象的 Kind 描述的是底层类型，而不是静态类型。如果一个反射对象包含一个用户定义的整数类型的值，如

type MyInt int
var x MyInt = 7
v := reflect.ValueOf(x)

v 的 Kind 仍然是 reflect.Int，即使 x 的静态类型是 MyInt，而不是 int。换句话说，Kind 无法区分 int 和 MyInt，尽管 Type 可以。

反射的第二定律

2. 反射从反射对象到接口值。

就像物理反射一样，Go 中的反射会产生它的逆过程。

给定一个 reflect.Value，我们可以使用 Interface 方法恢复一个接口值；实际上，该方法将类型和值信息打包回接口表示并返回结果

// Interface returns v's value as an interface{}.
func (v Value) Interface() interface{}

因此我们可以说

y := v.Interface().(float64) // y will have type float64.
fmt.Println(y)

来打印由反射对象 v 表示的 float64 值。

但是，我们可以做得更好。fmt.Println、fmt.Printf 等的参数都作为空接口值传递，然后由 fmt 包内部解包，就像我们之前在示例中所做的那样。因此，正确打印 reflect.Value 内容所需要做的就是将 Interface 方法的结果传递给格式化打印例程

fmt.Println(v.Interface())

（自从本文首次撰写以来，fmt 包发生了一个更改，使其会自动解包 reflect.Value，因此我们只需说

fmt.Println(v)

即可获得相同的结果，但为了清晰起见，我们在此处保留 .Interface() 调用。）

由于我们的值是 float64，我们甚至可以使用浮点格式，如果需要的话

fmt.Printf("value is %7.1e\n", v.Interface())

在这种情况下得到

3.4e+00

同样，无需将 v.Interface() 的结果进行类型断言为 float64；空接口值内部包含具体值的类型信息，Printf 会将其恢复。

简而言之，Interface 方法是 ValueOf 函数的逆操作，只是其结果始终是静态类型 interface{}。

重申：反射从接口值到反射对象，再返回。

反射的第三定律

3. 要修改反射对象，该值必须是可设置的。

第三定律是最微妙和令人困惑的，但如果我们从基本原理开始，就很容易理解。

这是一些不起作用的代码，但值得研究。

var x float64 = 3.4
v := reflect.ValueOf(x)
v.SetFloat(7.1) // Error: will panic.

如果你运行这段代码，它会因为一条神秘的消息而崩溃

panic: reflect.Value.SetFloat using unaddressable value

问题不在于值 7.1 不可寻址；而在于 v 不可设置。可设置性是反射 Value 的一个属性，并非所有反射 Value 都具有此属性。

Value 的 CanSet 方法报告 Value 的可设置性；在我们的例子中，

var x float64 = 3.4
v := reflect.ValueOf(x)
fmt.Println("settability of v:", v.CanSet())

打印

settability of v: false

在不可设置的 Value 上调用 Set 方法是错误的。但是什么是可设置性？

可设置性有点像可寻址性，但更严格。它是指反射对象可以修改用于创建反射对象的实际存储的属性。可设置性取决于反射对象是否持有原始项。当我们说

var x float64 = 3.4
v := reflect.ValueOf(x)

我们将 x 的副本传递给 reflect.ValueOf，因此作为 reflect.ValueOf 参数创建的接口值是 x 的副本，而不是 x 本身。因此，如果语句

v.SetFloat(7.1)

被允许成功，它不会更新 x，尽管 v 看起来是从 x 创建的。相反，它会更新存储在反射值内部的 x 的副本，而 x 本身将不受影响。这将是令人困惑和无用的，因此它是非法的，可设置性就是用来避免这个问题的属性。

如果这看起来很奇怪，那也不是。这实际上是一种熟悉的状况，只是披着不寻常的外衣。想想把 x 传递给一个函数

f(x)

我们不期望 f 能够修改 x，因为我们传递的是 x 值的一个副本，而不是 x 本身。如果希望 f 直接修改 x，我们必须将 x 的地址（即 x 的指针）传递给我们的函数

f(&x)

这既简单又熟悉，反射的工作方式也相同。如果我们要通过反射修改 x，我们必须向反射库提供我们想要修改的值的指针。

我们来这样做。首先，我们像往常一样初始化 x，然后创建一个指向它的反射值，称为 p。

var x float64 = 3.4
p := reflect.ValueOf(&x) // Note: take the address of x.
fmt.Println("type of p:", p.Type())
fmt.Println("settability of p:", p.CanSet())

到目前为止的输出是

type of p: *float64
settability of p: false

反射对象 p 不可设置，但我们不想设置 p，而是（实际上）*p。为了获取 p 指向的值，我们调用 Value 的 Elem 方法，它通过指针进行间接引用，并将结果保存到一个名为 v 的反射 Value 中

v := p.Elem()
fmt.Println("settability of v:", v.CanSet())

现在 v 是一个可设置的反射对象，正如输出所示，

settability of v: true

由于它代表 x，我们终于可以使用 v.SetFloat 修改 x 的值了

v.SetFloat(7.1)
fmt.Println(v.Interface())
fmt.Println(x)

输出，正如预期的那样，是

7.1
7.1

反射可能很难理解，但它所做的事情与语言完全相同，尽管是通过反射 Types 和 Values 来进行的，这可能会掩盖正在发生的事情。请记住，反射 Values 需要某物的地址才能修改它们所代表的内容。

结构体

在我们前面的例子中，v 本身不是指针，它只是从指针派生出来的。这种情况常见的发生方式是当使用反射修改结构体的字段时。只要我们拥有结构体的地址，我们就可以修改它的字段。

这是一个简单的示例，它分析一个结构体值 t。我们使用结构体的地址创建反射对象，因为稍后我们将要修改它。然后我们将 typeOfT 设置为其类型，并使用直接的方法调用遍历字段（有关详细信息，请参阅 reflect 包）。请注意，我们从结构体类型中提取字段名称，但字段本身是常规的 reflect.Value 对象。

type T struct {
    A int
    B string
}
t := T{23, "skidoo"}
s := reflect.ValueOf(&t).Elem()
typeOfT := s.Type()
for i := 0; i < s.NumField(); i++ {
    f := s.Field(i)
    fmt.Printf("%d: %s %s = %v\n", i,
        typeOfT.Field(i).Name, f.Type(), f.Interface())
}

这个程序的输出是

0: A int = 23
1: B string = skidoo

这里顺带提到了关于可设置性的一点：T 的字段名是大写（导出）的，因为结构体中只有导出字段才是可设置的。

由于 s 包含一个可设置的反射对象，我们可以修改结构体的字段。

s.Field(0).SetInt(77)
s.Field(1).SetString("Sunset Strip")
fmt.Println("t is now", t)

结果如下

t is now {77 Sunset Strip}

如果我们修改程序，使 s 是从 t 而不是 &t 创建的，那么对 SetInt 和 SetString 的调用将会失败，因为 t 的字段将不可设置。

结论

再此重申反射定律

• 反射从接口值到反射对象。

• 反射从反射对象到接口值。

• 要修改反射对象，该值必须是可设置的。

一旦你理解了这些定律，Go 中的反射就会变得更容易使用，尽管它仍然很微妙。它是一个强大的工具，应谨慎使用，除非绝对必要，否则应避免使用。

关于反射还有很多我们没有涉及到的内容——在通道上发送和接收，分配内存，使用切片和映射，调用方法和函数——但这篇博文已经足够长了。我们将在以后的文章中介绍其中一些主题。