反射（reflect）讓我們能在執行期探知物件地型別資訊和記憶體結構，這從一定程度上彌補了靜態語言在動態行為上地不足。
和C資料結構一樣，Go物件頭部並沒有型別指標，通過其自身是無法在執行期獲知任何型別相關資訊地。
反射操作所需地全部資訊都源自介面變數。介面變數除儲存自身型別外，還會儲存實際物件地型別資料。

func TypeOf(i interface{}) Type
func ValueOf(i interface{}) Value

這兩個反射入口函式，會將任何傳入的物件轉換為介面型別
在面對型別時，需要區分Type和Kind。前者表示真實型別（靜態型別），後者表示其基礎結構（底層型別）類別。

package main

import (
	"fmt"
	"reflect"
)

type X int

func main() {
	var a X = 100
	t := reflect.TypeOf(a)

	fmt.Println(t.Name(), t.Kind()) //X  int
}

所以在型別判斷上，須選擇正確方式。

package main

import (
	"fmt"
	"reflect"
)

type X int
type Y int

func main() {
	var a, b X = 100, 200
	var c Y = 300

	ta, tb, tc := reflect.TypeOf(a), reflect.TypeOf(b), reflect.TypeOf(c)
	fmt.Println(ta) //main.X
	fmt.Println(tb) //main.X
	fmt.Println(tc) //main.Y

	fmt.Println(ta == tb, ta == tc)     //true false
	fmt.Println(ta.Kind() == tc.Kind()) //true
}

除通過實踐物件獲取型別外，也可以直接構造一些基礎複合型別。

package main

import (
	"fmt"
	"reflect"
)

func main() {
	a := reflect.ArrayOf(10, reflect.TypeOf(byte(0)))
	m := reflect.MapOf(reflect.TypeOf(""), reflect.TypeOf(0))

	fmt.Println(a, m) //[10]uint8 map[string]int
}

傳入物件應區分基型別和指標型別，因為它們並不屬於同一型別。
方法Elem返回指標、陣列、切片、字典（值）或通道地基型別。

package main

import (
	"fmt"
	"reflect"
)

func main() {
	x := 100

	tx, tp := reflect.TypeOf(x), reflect.TypeOf(&x)

	fmt.Println(tx, tp, tx == tp)     //int *int false
	fmt.Println(tx.Kind(), tp.Kind()) //int ptr
	fmt.Println(tx == tp.Elem())      //true

	fmt.Println(reflect.TypeOf(map[string]int{}).Elem()) //int
	fmt.Println(reflect.TypeOf([]int32{}).Elem())        //int32
}

只有在獲取結構體指標地基型別之後，才能遍歷它的欄位。

package main

import (
	"fmt"
	"reflect"
)

type user struct {
	name string
	age  int
}

type manager struct {
	user  //只有型別而沒有名字，所以屬於匿名欄位
	title string
}

func main() {
	var m manager
	t := reflect.TypeOf(&m) //型別屬性資訊
	fmt.Println(t)          //*main.manager

	if t.Kind() == reflect.Ptr { //是否為指標型別
		t = t.Elem()
	}
	fmt.Println(t.NumField())           //2
	for i := 0; i < t.NumField(); i++ { //型別屬性中包含地的欄位
		f := t.Field(i) //取具體的欄位
		fmt.Println(f.Name, f.Type, f.Offset)

		if f.Anonymous { //輸出匿名欄位結構
			for x := 0; x < f.Type.NumField(); x++ {
				af := f.Type.Field(x)
				fmt.Println("  ", af.Name, af.Type)
			}
		}
	}
}

/*
user main.user 0
   name string
   age int
title string 24
*/

對於匿名欄位，可用於多級索引（按定義順序）直接訪問。

package main

import (
	"fmt"
	"reflect"
)

type user struct {
	name string
	age  int
}

type manager struct {
	user
	title string
}

func main() {
	var m manager

	t := reflect.TypeOf(m)
	fmt.Println(t)                    //main.manager
	name, _ := t.FieldByName("name")  //按照欄位名稱查詢，
	fmt.Println(name)                 //{name main string  0 [0 0] false}  取到的是一個物件實體
	fmt.Println(name.Name, name.Type) //name string

	age := t.FieldByIndex([]int{0, 1}) //按多級索引查詢  //0——》user  1——》age
	fmt.Println(age.Name, age.Type)    //age int
}

FieldByName不支援多級名稱，如有遮蔽，需通過匿名欄位二次獲取。

同樣，輸出方法集時，一樣區分基型別和指標型別。

package main

import (
	"fmt"
	"reflect"
)

type A int

type B struct {
	A
}

func (A) av()  {}
func (*A) ap() {}
func (B) bv()  {}
func (*B) bp() {}

func main() {
	var b B
	t := reflect.TypeOf(&b)
	s := []reflect.Type{t, t.Elem()}

	for _, t := range s {
		fmt.Println(t, ":")

		for i := 0; i < t.NumMethod(); i++ {
			fmt.Println("  ", t.Method(i))
		}
	}
}

有一點和想象不同，反射能探知當前包或外包的非匯出結構成員
相對reflect而言，當前包和外包都是“外包”。

package main

import (
	"fmt"
	"net/http"
	"reflect"
)

func main() {
	var s http.Server
	t := reflect.TypeOf(s)

	for i := 0; i < t.NumField(); i++ {
		fmt.Println(t.Field(i).Name)
	}
}

/*
Addr
Handler
TLSConfig
ReadTimeout
ReadHeaderTimeout
WriteTimeout
IdleTimeout
MaxHeaderBytes
TLSNextProto
ConnState
ErrorLog
disableKeepAlives
inShutdown
nextProtoOnce
nextProtoErr
mu
listeners
activeConn
doneChan
onShutdown
*/

可用反射提取struct tag，還能自動分解。其常用於ORM對映，或資料格式驗證。

package main

import (
	"fmt"
	"reflect"
)

type user struct {
	name string `field:"name" type:"varchar(50)"`
	age  int    `field:"age"  type:"int"`
}

func main() {
	var u user
	t := reflect.TypeOf(u)
	for i := 0; i < t.NumField(); i++ {
		f := t.Field(i)
		fmt.Printf("%s:%s %s\n", f.Name, f.Tag.Get("field"), f.Tag.Get("type"))
	}
}

/*
name:name varchar(50)
age:age int
*/

和Type獲取型別資訊不同，value專注於物件例項資料讀寫。
之前說過，介面變數會賦值物件，且是unaddressable的，所以要想修改目標物件，就必須使用指標。

package main

import (
	"fmt"
	"reflect"
)

func main() {
	a := 100
	va, vp := reflect.ValueOf(a), reflect.ValueOf(&a).Elem()

	fmt.Println(va.CanAddr(), va.CanSet()) //false false
	fmt.Println(vp.CanAddr(), vp.CanSet()) //true true
}

就算傳入指標，一樣需要通過Elem獲取目標物件。
因為被介面儲存的指標本身是不能定址和進行設定操作的。

注意，不能對非匯出欄位直接進行設定操作，無論是當前包還是外包。

package main

import (
	"fmt"
	"reflect"
	"unsafe"
)

type User struct {
	Name string
	code int
}

func main() {
	p := new(User)
	v := reflect.ValueOf(p).Elem()

	name := v.FieldByName("Name")
	code := v.FieldByName("code")

	fmt.Printf("name: canaddr = %v, canset = %v\n", name.CanAddr(), name.CanSet())
	fmt.Printf("code: canaddr = %v, canset = %v\n", code.CanAddr(), code.CanSet())

	if name.CanSet() {
		name.SetString("kebi")
	}

	if code.CanAddr() {
		*(*int)(unsafe.Pointer(code.UnsafeAddr())) = 100
	}
	fmt.Printf("%+v\n", *p)
}

/*
name: canaddr = true, canset = true
code: canaddr = true, canset = false
{Name:kebi code:100}
*/

可通過Interface方法進行型別推斷和轉換。

package main

import (
	"fmt"
	"reflect"
)

func main() {
	type user struct {
		Name string
		Age  int
	}

	u := user{
		"kebi",
		26,
	}

	v := reflect.ValueOf(&u)

	if !v.CanInterface() {
		fmt.Println("caninterface:fail")
		return
	}

	p, ok := v.Interface().(*user)
	if !ok {
		fmt.Println("interface:fail")
		return
	}
	p.Age++
	fmt.Printf("%+v\n", u) //{Name:kebi Age:27}
}

也可以直接使用value.Int,Bool等方法進行型別轉換，但失敗時會引發panic，且不支援ok-idiom。
複合型別物件設定示例。

package main

import (
	"fmt"
	"reflect"
)

func main() {
	c := make(chan int, 4)
	v := reflect.ValueOf(c)

	if v.TrySend(reflect.ValueOf(100)) {
		fmt.Println(v.TryRecv()) //100 true
	}
}

介面有兩種nil狀態，這是一個潛在麻煩。解決方法是用IsNil判斷值是否為nil。

package main

import (
	"fmt"
	"reflect"
)

func main() {
	var a interface{} = nil
	var b interface{} = (*int)(nil)

	fmt.Println(a == nil)                             //true
	fmt.Println(b == nil, reflect.ValueOf(b).IsNil()) //false  true
}

也可用unsafe轉換後直接判斷iface.data是否為零值。

package main

import (
	"fmt"
	"unsafe"
)

func main() {
	var b interface{} = (*int)(nil)
	ifac := (*[2]uintptr)(unsafe.Pointer(&b))

	fmt.Println(ifac, ifac[1] == 0) //&[4825024 0] true
}

動態呼叫方法，只須按照in列表準備好所需引數即可。

package main

import (
	"fmt"
	"reflect"
)

type X struct{} //結構體

func (X) Test(x, y int) (int, error) { //方法
	return x + y, fmt.Errorf("err: %d", x+y)
}

func main() {
	var a X
	v := reflect.ValueOf(&a)    //
	m := v.MethodByName("Test") //根據方法名獲取程式實體

	in := []reflect.Value{ //構建切片資料
		reflect.ValueOf(1),
		reflect.ValueOf(2),
	}

	out := m.Call(in)
	for _, v := range out {
		fmt.Println(v)
	}
}

/*
3
err: 3
*/

對於變參來說，用CallSlice要更方便一些。

package main

import (
	"fmt"
	"reflect"
)

type X struct{}

func (X) Format(s string, a ...interface{}) string {
	return fmt.Sprintf(s, a...)
}

func main() {
	var a X

	v := reflect.ValueOf(&a)
	m := v.MethodByName("Format")

	out := m.Call([]reflect.Value{
		reflect.ValueOf("%s = %d"),
		reflect.ValueOf("x"),
		reflect.ValueOf(100),
	})

	fmt.Println(out)

	out = m.CallSlice([]reflect.Value{
		reflect.ValueOf("%s = %d"),
		reflect.ValueOf([]interface{}{"x", 100}),
	})
	fmt.Println(out)
}

/*
[x = 100]
[x = 100]
*/