完成11.10章节

eBook/11.10.md

@@ -0,0 +1,280 @@
+# 11.10 反射包
+
+## 11.10.1 方法和类型的反射
+在10.4节我们看到可以通过反射来分析一个结构体。本节我们进一步探讨强大的反射功能。反射是用程序检查其所拥有的结构，尤其是类型的一种能力；这是元编程的一种形式。反射可以在运行时检查类型和变量，例如它的大小、方法和`动态`的调用这些方法。这对于没有源代码的包尤其有用。这是一个强大的工具，除非真得有必要，否则应当避免使用或小心使用。
+
+变量的最基本信息就是类型和值：反射包的`Type`用来表示一个Go类型，反射包的`Value`为Go值提供了反射接口。
+
+两个简单的函数,`reflect.TypeOf`和`reflect.ValueOf`，返回被检查对象的类型和值。例如，x被定义为：`var x float64 = 3.4`,那么`reflect.TypeOf(x)`返回`float64`，`reflect.ValueOf(x)`返回`<float64 Value>`
+
+实际上，反射是通过检查一个接口的值，变量首先被转换成空接口。这从下面两个函数签名能够很明显的看出来：
+
+```go
+	func TypeOf(i interface{}) Type
+	func ValueOf(i interface{}) Value
+```
+
+接口的值包含一个type和value.
+
+反射可以从接口值反射到对象，也可以从对象反射回接口值。
+
+reflect.Type 和 reflect.Value 都有许多方法用于检查和操作它们。一个重要的例子是 Value 有一个 Type 方法返回 reflect.Value 的 Type。另一个是 Type 和 Value 都有 Kind 方法返回一个常量来表示类型：Uint、Float64、Slice 等等。同样 Value 有叫做 Int 和 Float 的方法可以获取存储在内部的值（跟 int64 和 float64 一样）
+
+```go
+const (
+	Invalid Kind = iota
+	Bool
+	Int
+	Int8
+	Int16
+	Int32
+	Int64
+	Uint
+	Uint8
+	Uint16
+	Uint32
+	Uint64
+	Uintptr
+	Float32
+	Float64
+	Complex64
+	Complex128
+	Array
+	Chan
+	Func
+	Interface
+	Map
+	Ptr
+	Slice
+	String
+	Struct
+	UnsafePointer
+)
+```
+
+对于变量x,如果`v:=reflect.ValueOf(x)`那么`v.Kind()`返回float64，所以下面的表达式是`true`
+`v.Kind() == reflect.Float64`
+
+Kind总是返回底层类型: 
+
+```go
+	type MyInt int
+	var m MyInt = 5
+	v := reflect.ValueOf(m)
+```
+
+`v.Kind()`返回`reflect.Int`
+
+`Interface()`方法还原(接口)值的值，所以要打印v的值：`fmt.Println(v.Interface())`
+
+
+尝试运行下面的代码：
+
+示例 11.11 reflect1.go:
+
+```go
+// blog: Laws of Reflection
+package main
+
+import (
+	"fmt"
+	"reflect"
+)
+
+func main() {
+	var x float64 = 3.4
+	fmt.Println("type:", reflect.TypeOf(x))
+	v := reflect.ValueOf(x)
+	fmt.Println("value:", v)
+	fmt.Println("type:", v.Type())
+	fmt.Println("kind:", v.Kind())
+	fmt.Println("value:", v.Float())
+	fmt.Println(v.Interface())
+	fmt.Printf("value is %5.2e\n", v.Interface())
+	y := v.Interface().(float64)
+	fmt.Println(y)
+}
+
+/* output:
+type: float64
+value: <float64 Value>
+type: float64
+kind: float64
+value: 3.4
+3.4
+value is 3.40e+00
+3.4
+*/
+```
+
+知道x是一个float64类型的值，`reflect.ValueOf(x).float()`返回这个float64类型的实际值；同样的适用于`Int(), Bool(), Complex() ,String()`
+
+## 11.10.2 通过反射修改(设置)值
+继续前面的例子(参阅11.9 reflect2.go),假设我们把x的值改为3.1415。Value有一些方法可以完成这个任务，但是必须小心使用：`v.SetFloat(3.1415)`
+
+这将产生一个错误： `will panic: reflect.Value.SetFloat using unaddressable value`
+
+为什么会这样呢？问题的原因是v不是可设置的(这里并不是说值不可寻址)。是否可设置是Value的一个属性，并且不是所有的反设值都有这个属性：可以使用`CanSet()`方法测试是否可设置。
+
+在例子中我们看到`v.CanSet()`返回false: `settability of v: false`
+
+当`v := reflect.ValueOf(x) `函数通过传递一个x拷贝创建了v，那么v的改变并不能更改原始的x。要想v的更改能作用到x,那就必须传递x的地址`v = reflect.ValueOf(&x)`。
+
+通过Type()我们看到v现在的类型是*float64并且仍然是不可设置的。
+
+要想让其可设置我们需要使用`Elem()`函数，这间接的使用指针:`v = v.Elem()`
+
+现在`v.CanSet()`返回true并且`v.SetFloat(3.1415)`设置成功了！
+
+
+示例 11.12 reflect2.go:
+
+```go
+// reflect2.go
+package main
+
+import (
+	"fmt"
+	"reflect"
+)
+
+func main() {
+	var x float64 = 3.4
+	v := reflect.ValueOf(x)
+	// setting a value:
+	// v.SetFloat(3.1415) // Error: will panic: reflect.Value.SetFloat using unaddressable value
+	fmt.Println("settability of v:", v.CanSet())
+	v = reflect.ValueOf(&x) // Note: take the address of x.
+	fmt.Println("type of v:", v.Type())
+	fmt.Println("settability of v:", v.CanSet())
+	v = v.Elem()
+	fmt.Println("The Elem of v is: ", v)
+	fmt.Println("settability of v:", v.CanSet())
+	v.SetFloat(3.1415) // this works!
+	fmt.Println(v.Interface())
+	fmt.Println(v)
+}
+
+/* Output:
+settability of v: false
+type of v: *float64
+settability of v: false
+The Elem of v is:  <float64 Value>
+settability of v: true
+3.1415
+<float64 Value>
+*/
+```
+
+反射中有些内容是需要用地址去改变它的状态的。
+
+## 11.10.3 反射结构
+有些时候需要反射一个结构类型。NumField()方法返回结构内的字段数量；可以通过一个for循环通过索引取得每个字段的值`Field(i)`。
+
+我们同样能够调用签名在结构上的方法，例如，使用索引n来调用:`Method(n).Call(nil)`
+
+示例 11.13 reflect_struct.go:
+
+```go
+// reflect.go
+package main
+
+import (
+	"fmt"
+	"reflect"
+)
+
+type NotknownType struct {
+	s1, s2, s3 string
+}
+
+func (n NotknownType) String() string {
+	return n.s1 + " - " + n.s2 + " - " + n.s3
+}
+
+// variable to investigate:
+var secret interface{} = NotknownType{"Ada", "Go", "Oberon"}
+
+func main() {
+	value := reflect.ValueOf(secret) // <main.NotknownType Value>
+	typ := reflect.TypeOf(secret)    // main.NotknownType
+	// alternative:
+	//typ := value.Type()  // main.NotknownType
+	fmt.Println(typ)
+	knd := value.Kind() // struct
+	fmt.Println(knd)
+
+	// iterate through the fields of the struct:
+	for i := 0; i < value.NumField(); i++ {
+		fmt.Printf("Field %d: %v\n", i, value.Field(i))
+		// error: panic: reflect.Value.SetString using value obtained using unexported field
+		//value.Field(i).SetString("C#")
+	}
+
+	// call the first method, which is String():
+	results := value.Method(0).Call(nil)
+	fmt.Println(results) // [Ada - Go - Oberon]
+}
+
+/* Output:
+main.NotknownType
+struct
+Field 0: Ada
+Field 1: Go
+Field 2: Oberon
+[Ada - Go - Oberon]
+*/
+```
+
+但是如果尝试更改一个值，会得到一个错：
+
+```
+	panic: reflect.Value.SetString using value obtained using unexported field
+```
+
+这是因为结构中只有被导出字段(首字母大写)才是可设置的；来看下面的例子:
+
+示例 11.14 reflect_struct2.go:
+
+```go
+// reflect_struct2.go
+package main
+
+import (
+	"fmt"
+	"reflect"
+)
+
+type T struct {
+	A int
+	B string
+}
+
+func main() {
+	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())
+	}
+	s.Field(0).SetInt(77)
+	s.Field(1).SetString("Sunset Strip")
+	fmt.Println("t is now", t)
+}
+
+/* Output:
+0: A int = 23
+1: B string = skidoo
+t is now {77 Sunset Strip}
+*/
+
+```
+附录37深入阐述了反射概念。
+
+## 链接
+
+- [目录](directory.md)
+- 上一节：[空接口](11.9.md)
+- 下一节：[Printf和反射](11.11.md)