【译文】原文地址
关于Go反射这个主题，需要理解Go内部关于结构体、接口和类型系统，才能理解反射的底层工作机制。当然，您也使用反射，而不需要深入理解这些细节。本文的目标是向您介绍一些细节，使您能够更深入地理解反射。但是这些不是严格要求的。这篇文章假设您对结构体和接口有基本的了解。你可以通过"Go by example"快速浏览下结构体和接口，也可以深入学习下Go的结构体和接口。
什么是反射
In computer science, reflection is the ability of a process to examine, introspect, and modify its own structure and behavior. — Wikipedia
维基百科上面解释到，在计算机科学中，反射是一种能够对结构体和行为（本人理解为函数或者方法）进行检查、内省的过程。
反射是程序运行时的操作。它是一种元编程形式，但并不是所有的元编程都是反射。
为什么反射对Go语言重要
反射在很多方面都起作用。通过本文我将关注最明显的一个作用。Go作为一种静态编程语言，你必须提前声明所有类型才可以使用。因此，你没办法处理事先不清楚的类型，即使你需要对它进行操作、检查你也不需要了解这些信息。
一个典型的例子就是fmt包中的print函数。如果你想打印一个变量的类型可以使用%T，fmt包不需要知道你自定义的Person结构体。但是它还是能打印出Person接头体内容。
空接口
接口是一种定义了多个方法的类型，实现了这些方法的结构体就实现了该接口。这允许将接口作为一种类型传给方法使用，您可以将实现了该接口的结构体传入方法。对于一个空接口，每个结构体和每个基本类型，内建实现了空接口。
因此，使用空接口作为类型的函数参数，可以接受任意类型参数。
func main() {
x := 100
fmt.Println(x+1)
myPrint(x)
}
func myPrint(item interface{}) {
fmt.Println(item)
}
上面的代码可以正常工作，第一个print将打印101，因为对类型int的变量x执行了+1操作，然后将x传给Println，该函数也是接收一个空接口作为参数，内部是反射实现。
但是Go还是一个静态类型语言，所以使用空接口将不允许您对变量进行任何其他操作（除非使用类型断言或反射）。
func main() {
x := 100
myPrint(x)
}
func myPrint(item interface{}) {
fmt.Println(item+1)
fmt.Println(item)
}
上面的代码无法编译通过，在myPrint函数中，item是空接口类型，即使底层是整形，但是Go并不知道它，因此代码会panic。
类型断言
类型断言可以帮助你验证变量的实际类型，如果它是您断言的类型，就会以这种类型来获取对应值。
func main() {
var myVar interface{} = 10
v, ok := myVar.(int)
if (ok) {
fmt.Println(v)
}
}
上面的代码会打印10，因为我们使用myVar.(int)得到对应的原始类型。断言成功的话，v将赋值为对应类型变量，ok将赋值为bool值。
关于类型断言的更多内容，，如果您感兴趣的话可以浏览类型断言和类型切换。
类型实现细节在哪里呢？
类型断言（以及代理，反射）是如何知道一个通用接口（空接口）的底层类型的呢。
要理解这点，需要通过/src/sync/atomic/value.go直接看go实现。它实现了go中每个变量的基础值。
// ifaceWords is interface{} internal representation.
type ifaceWords struct {
typ unsafe.Pointer
data unsafe.Pointer
}
空接口和go通过扩展的每个值，在底层表示中包括两个unsafe指针：typ和data。
- typ保存当前变量的类型信息，因此即使一个变量是空接口，实际的类型信息在typ中是完整的。
- data保存值本身，还有其他数据信息如kind值，这个不在本文讨论范围之内。重点是data保存类型的值信息。
类型断言缺少什么？（或者为何需要反射）
当你知道要检查的类型时，断言允许验证和使用接口的底层类型值。在前面的例子中，我们专门为int使用断言。因为我们提前知道其类型，以便断言可以正常工作。即使我们用switch多个case来检查，我们仍然必须知道在编译时断言的具体类型。
在编译时不知道具体的类型情况下，就需要反射了。或者换句话说，如本文开头所述，当我们需要在运行时检查。回想下fmt例子，fmt包并不知道结构体类型但仍然可以打印它的值和类型（使用%T）。
反射
Reflect.Type和Reflect.Value是反射包提供的两个基本且最终要的类型。它们是Reflect包中定义的两个结构体，reflect包有操作接口变量的方法，底层实现其实都是通过将接口的typ和data信息复制到这两个结构体上。这样通过这两个结构体对应的方法即可处理接口了。
Reflect.TypeOf()和Reflect.ValueOf()是两个可用的基本方法，分别返回Reflect.Type和Reflect.Value，如下所示：
import (
"fmt"
"reflect"
)
func main() {
var myVar interface{} = 10
myType := reflect.TypeOf(myVar)
myValue := reflect.ValueOf(myVar)
fmt.Println(myType) // > int
fmt.Println(myValue) // > 10
}
为了更清楚的说明：我们可以看一下自己定义的struct例子：
type Person struct {
name string
}
func main() {
var myPerson interface{} = Person{name: "Snir David"}
myType := reflect.TypeOf(myPerson)
myValue := reflect.ValueOf(myPerson)
fmt.Println(myType) // > main.Person
fmt.Println(myValue) // > {Snir David}
}
使用TypeOf和VauleOf返回底层类型，和一个指向值的指针。需要注意的是ValueOf返回的的值类型是Reflect.Value类型的，并不是变量原始类型。
例如，前面的例子中，我们不能取接口的值并对其做算数运算，比如myValue + 1。这是无法通过编译的，因为Go编译器无法根据Reflect.Value类型识别这个操作，但对原始类型int是可识别的。
Reflect.Kind
The kind is what the type is made of — a slice, a map, a pointer, a struct, an interface, a string, an array, a function, an int or some other primitive type.
理解Kind是有点棘手的，而且网上的一些介绍也会让您感到困惑，因为大部分介绍kind都是根据type理论，和讨论Haskell之类的语言实现。
关于Go你需要知道的是，每个变量都有一个Kind类型，是从type派生出来的。Kind可以理解为是类型中的类型。
最容易说清楚kind概念就是自己定义的结构体。让我们回到前面创建Person结构体的代码。我们定义的myPerson是一个Person类型。Person结构体本身类型，即Kind是struct。获取kind类型可以通过对Reflect.Type变量使用Kind()方法
例如上面的代码可以修改为：
myKind := reflect.TypeOf(myPerson).Kind()
可以在如下链接查看所有的Kind值：
https://golang.org/pkg/reflect/#Kind
对一些例子，不像上面struct比较明显，Kind看起来似乎有点重复。例如type是int64其Kind也是int64。无需强调的是，我们了解Kind是因为它有助于重用空接口值（译者：这里似乎没解释清楚）。
将Reflect.Value转换为原始类型值
因此我们根据Reflect.ValueOf()函数可以对一个空接口类型变量进行分析，并得到一个类型为Rreflect.Value值。但是这个值并不正真有用，因为Go类型系统无法识别出它的原始类型。
我们希望将该值转换成其原始类型。这个过程如下：
1、使用Reflect.TypeOf或Reflect.Kind()识别出其原始类型。
2、使用指向值的指针来获取原始值（unsafe指针不在本文范围内）
3、对指针进行类型转换
很幸运，reflect包已经提供了处理所有的基本类型转换函数。如下所示：
func main() {
var myVar interface{} = 10
reflectValue := reflect.ValueOf(myVar)
intValue := reflectValue.Int()
// Arithmetic will now work, as this is typed int
fmt.Println(intValue + 1) // > 11
}
所有的基本类型都有转换方法可用，Bool、Float、String等。
复杂类型的探究
上面介绍了基本类型，但是我们如何处理结构体呢？
reflect包也提供了方法来查看结构体内部信息。如下代码所示：
type Person struct {
name string
age int
}
func investigateStruct(s interface{}) {
reflValue := reflect.ValueOf(s)
// Make sure we are handling with a struct here
if (reflValue.Kind() == reflect.Struct) {
fieldCount := reflValue.NumField()
fmt.Println("Num of fields: ", fieldCount)
for i := 0; i < fieldCount; i++ {
// Get individual field details
field := reflValue.Field(i)
fmt.Printf("type: %T, value: %v \n", field, field)
}
}
}
func main() {
var myVar interface{} = Person{name: "Snir", age: 27}
investigateStruct(myVar)
}
Output:
Num of fields: 2
type: reflect.Value, value: Snir
type: reflect.Value, value: 27
以上代码查看了结构体中包含的字段数，以及每个字段类型和值。
