Golang 的反射法则

原文链接：https://blog.golang.org/laws-of-reflection

Introduction

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

在这篇文章中，我们试着通过解释Go中的反射如何运作来澄清一些事情。每个语言的反射模型都不同（许多语言不支持），这篇文章仅仅介绍Go的反射，因此以后文章中提到的反射，都是指Go中的反射。

    Types and interfaces

因为反射是建立在类型系统上的，我们从复习Go的类型开始。

Go是静态类型的语言。每个变量有一个静态类型，意味着，在编译时只有一个固定的类型：int，float32，*MyType，[]byte等。如果我们声明：

type MyInt int

var i int

var j MyInt

i 是int类型，j是MyInt类型。变量 i 和 j 是不同的静态类型，即使他们底层类型相同，他们在没有转换的前提下不能赋值为另外一个类型。

一个重要的类型是interface类型，代表一组固定的方法。一个接口变量可以存储任何实体类型（非interface）值，只要那个变量实现了interface的所有方法。一个众所周知的例子是io.Read和io.Writer，Reader和Wirter类型来自io package：

// 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类型的变量可以hold任何 有Read方法的类型值：

var r io.Reader

r = os.Stdin

r = bufio.NewReader(r)

r = new(bytes.Buffer)

// and so on

这点非常重要，不管 r hold什么实体类型的值，r 的类型永远是 io.Reader：Go是静态类型的 并且 r的静态类型是io.Reader。

一个及其重要的interface的例子是空interface：

interface {}

它表示一个空的方法集，并且匹配任何值，因为任何值都有0个或多个方法。

有些人表示，Go的interface是动态类型的，但那是误导。他们是静态类型：一个interface类型的变量总是相同的静态类型，并且即使在run time，存储在interface变量中的值可能会改变类型，但是那个值总是满足interface。

我们需要很清晰的了解这些，因为反射和interface极其相关。

    The representation of an interface

Russ Cox 写了一篇关于interface的文章。这里没必要重复一遍，按此简化。（ 参见上篇翻译文章《golang interface的使用和实现》）

一个interface类型的变量存储一对word值：一个指向实体类型的值，和值的类型描述符。更精确点，该值是实现接口的基础数据项，类型描述该数据项的完整类型。例如，

var r io.Reader

tty, err := os.OpenFile("/dev/tty", os.O_RDWR, 0)

if err != nil {

return nil, err

}

r = tty

r 包含，按顺序，（value，type）对，（tty, *os.File）。注意*os.File类型也可以实现除Rad以外的其他方法；即使interface值仅仅提供对Rad方法的访问，这个值包含有关该值的所有类型信息。所以我们可以这么做：

var w io.Writer

w = r.(io.Writer)

上面的赋值语句是类型断言；断言的内容为，r内部也实现了io.Writer，所以我们可以将它赋值给w。赋值后，w将会包含（tty, *os.File）。与 r 中存储的数据一样。interface的静态类型决定了interface变量可以调用什么方法，即使实体类型可能有一组很大的方法表。

继续，我们可以这样做：

var empty interface{}

empty = w

同样，我们的空的interface也包含相同的对，（tty，*os.File）。这很方便，一个空的interface可以保存任何值，并包含我们可能需要的关于该值的所有信息。

（我们不需要在此做类型断言，因为w满足空interface。在我们从Reader移动值到Writer的例子中，我们需要类型断言，因为Writer的方法不是Reader方法的子集。）

一个重要的细节是，一个interface总是（value，concrete type）形式，不能是（value，interface type）形式。interface不能hold interface值。

准备学习反射。

    The first law of reflection

1. 反射从interface值到反射对象。（Reflection goes from interface value to reflection object）

在基本层面上，反射只是一种 检查 存储在interface值中的类型和值对 的 机制。在开始前，我们需要了解reflect package中的Type和Value。这两个类型可以访问interface变量的内容，另外两个简单的函数， reflect.TypeOf和reflect.ValueOf，从interface值中检索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

你可能好奇，interface在哪，由于程序看起来像传递了一个类型为float64的变量x，而不是一个interface值，到reflect.TypeOf。 但是，reflect.TypeOf的函数签名，参数是为空interface：

// TypeOf returns the reflection Type of the value in the interface{}.

func TypeOf(i interface{}) Type

当我们调用reflect.TypeOf(x)时，x 首先保存到一个空interface中；reflect.TypeOf 从空interface中取出类型信息。

reflect.ValueOf函数，当然，取出值（从这里开始，我们只关注可执行代码）：

var x float64 = 3.4

fmt.Println("value:", reflect.ValueOf(x).String())

输出：

value: <float64 Value>

（我们明确调用String方法，因为默认fmt package会深入reflect.Value中，显示内部的实体值。而String方法不会。）

reflect.Type 和 reflect.Value 都有许多可以检测和操作的方法。一个重要的例子是，Value有一个Type方法，返回reflect.Value的类型。另一个是，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不能区分来自MyInt的int，但是Type可以。

    The second law of reflection

2. 反射从反向对象到interface值（Reflection goes from reflection object to interface value）

像物理反射一样，Go中的反射生成其自身的反向。

给一个reflect.Value，我们可以使用Interface方法恢复一个interface的值；方法打包类型和值信息到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等等的参数，都是作为空interface值传入的，在fmt package内部被unpack（之前提到这个例子）。因此，正确输出reflect.Value 所要做的就是传递Interface方法的结果到 格式化输出例程：

fmt.Println(v.Interface())

（为什么不是fmt.Println(v)？因为v是一个reflect.Value；我们需要其hold的实体类型的值）因为我们的值是float64类型，我们甚至可以使用一个 floating-point 格式，如果我们想的话：

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

输出：

3.4e+00

这里再次无需做v.Interface()的类型断言float64；空interface的值内部有实体类型的值信息。Printf将会恢复它。

简而言之，Interface方法就是ValueOf的反向函数，除了它的结果总是静态类型interface{}。

重申：反射是从interface值到反射对象，然后再反过来。

    The third law of reflection

3. 要修改一个反射对象，值必须是可以设置的（To modify a reflection object, the value must be settable）

第三个法则是最微妙和令人困惑的，但是我们从第一个法则学过来的话理解起来会比较简单。

下面的代码不能工作，但是值得学习下：

var x float64 = 3.4

v := reflect.ValueOf(x)

v.SetFloat(7.1) // Error: will panic.

如果你运行这段代码，将会panic，并输出以下难以理解的消息：

panic: reflect.Value.SetFloat using unaddressable value

问题不是值7.1不能寻址；问题是 v 不能被设置。可设置性是反射值的一个属性，并不是所有的反射值都有。

值的CanSet方法报告值是否可以设置；

var x float64 = 3.4

v := reflect.ValueOf(x)

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

输出：

settability of v: false

可设置性有点类似 可寻址，但是更严格。是否可修改反射对象的实际存储的值（用来创建反射对象的实际的存储的值）是一个属性。可设置性由 是否反射对象hold原item决定。看下面的代码：

var x float64 = 3.4

v := reflect.ValueOf(x)

我们传递了一个copy 到 reflect.ValueOf，因此 传递给reflect.ValueOf 的 interface值是x的copy，而不是x本身。因此，如果下面的语句：

v.SetFloat(7.1)

允许成功的话，它不会更新x，即使 v 看起来是从 x 创建的。相反，它将更新存储在反射值内的 x的copy，x本身将不受影响。那样会让人困惑，并且没有什么用，因此是非法的，可设置性是为了避免这种情况的属性值。

如果这看起来很古怪，其实并不是。这是熟悉的情形，但是不同的形式。想象传递x到函数：

f(x)

我们不希望f可以修改x，因为我们传递了x的一个copy，不是x本身。如果我们想要f 直接修改x，我们必须传递x的地址（即，指向x的指针）：

f(&x)

这样简单并且熟悉，反射类似这种方式工作。如果我们想通过反射修改x，我们必须传递想要修改的值的指针。

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

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指向的值，我们调用值的Elem方法（通过指针间接指向），保存反射值到v：

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

反射很难理解，但是正确实现了语言的功能，尽管反射的类型和值掩盖了一些底层的实现。记住，要修改反射值需要指向该值的地址。

Structs

在上个例子中，v本身并不是一个指针，是从一个指针派生过来的。常见的情形是使用反射来修改struct的字段。只要我们有这个结构的地址，我们就可以修改它的字段。

有个简单的列子，可以分析struct值，t。我们使用struct的地址创建反射对象，因为后面要修改它的值。我们将typeOfT设置为其类型，并使用直接的方法调用 遍历字段。注意，我们从struct类型中取出字段名，但是字段本身是普通的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 struct的字段名都是大写的，因为只有暴露的字段才可以设置。

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

s.Field(0).SetInt(77)

s.Field(1).SetString("Sunset Strip")

fmt.Println("t is now", t)

输出：

t is now {77 Sunset Strip}

如果我们将 &t 改为 t，SetInt和SetString调用将会失败，因为 t 的字段不可设置。

    Conclusion

下面重复下三个法则：

1. 反射从interface 值 到 反射对象。

2. 反射从反射对象到interface 值。

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

一旦你理解了Go的这些反射法则，将会变得更好使用，尽管仍然有些微妙的地方。这是个强大的工具，应谨慎使用，如非必要避免使用。

还有一些内容这里没有介绍，在channel上发送和接收，分配内存，使用slice和map，调用方法和函数，但是这个文章已经很长了。。。我们将会在后续的主题中介绍