reflect包實現了運行時反射，允許程序操作任意類型的對象。典型用法是用靜態類型interface{}保存一個值，通過調用TypeOf獲取其動態類型信息，該函數返回一個Type類型值。
調用ValueOf函數返回一個Value類型值，該值代表運行時的數據。

func TypeOf(i interface{}) Type

TypeOf返回接口中保存的值的類型，TypeOf(nil)會返回nil。

func ValueOf(i interface{}) Value

ValueOf返回一個初始化為i接口保管的具體值的Value，ValueOf(nil)返回Value零值。

獲取變量的值：

reflect.ValueOf(x).Int()
reflect.ValueOf(x).Float() 
reflect.ValueOf(x).String()
reflect.ValueOf(x).Bool()

通過反射的來改變變量的值reflect.Value.SetXX相關方法

reflect.Value.SetInt()，//設置整數
reflect.Value.SetFloat()，//設置浮點數
reflect.Value.SetString()，//設置字符串

反射結構體

reflect.Value.NumField()獲取結構體中字段的個數
reflect.Value.Method(n).Call(nil)來調用結構體中的方法

type NotknownType struct {
    S1,S2,S3 string
}

func (n NotknownType) String() string {
    return n.S1 + "  " + n.S2 + "  " + n.S3
}

var secret = NotknownType{"Go", "C", "c++"}

func main() {
    value := reflect.ValueOf(secret)
    fmt.Println(value) //Go  C  c++
    typ := reflect.TypeOf(secret)
    fmt.Println(typ) //main.NotknownType

    knd := value.Kind()
    fmt.Println(knd) // struct

    for i := 0; i < value.NumField(); i++ {
        fmt.Printf("Field %d: %v\n", i, value.Field(i))
    }

    results := value.Method(0).Call(nil)
    fmt.Println(results) // [Go  C  c++]
}
 

反射修改值

SetXX(x) 因為傳遞的是 x 的值的副本，所以SetXX不能夠改 x，改動 x 必須向函數傳遞 x 的指針，SetXX(&x) 。

func main() {
    var a int = 2
    fv := reflect.ValueOf(&a)
    fv.Elem().SetInt(5)
    fmt.Printf("%v\n", a) //5
}

通過reflect.ValueOf來進行方法的調用

import (
    "fmt"
    "reflect"
)

type User struct {
    Id int
    Name string
    Age int
}

func (u User)ReflectCallFuncHasArgs(name string,age int){
    fmt.Println("ReflectCallFuncHasArgs name: ", name, ", age:", age, "and origal User.Name:", u.Name)
}
func (u User) ReflectCallFuncNoArgs() {
    fmt.Println("ReflectCallFuncNoArgs")
}

func main() {

    user := User{1, "Allen.Wu", 20}

    // 1. 要通過反射來調用起對應的方法，必須要先通過reflect.ValueOf(interface)來獲取到reflect.Value，得到“反射類型對象”後才能做下一步處理
    getValue := reflect.ValueOf(user)

    // 一定要指定參數為正確的方法名
    // 2. 先看看帶有參數的調用方法
    methodValue := getValue.MethodByName("ReflectCallFuncHasArgs")
    args := []reflect.Value{reflect.ValueOf("testUser"), reflect.ValueOf(18)}
    methodValue.Call(args)

    // 一定要指定參數為正確的方法名
    // 3. 再看看無參數的調用方法
    methodValue = getValue.MethodByName("ReflectCallFuncNoArgs")
    args = make([]reflect.Value, 0)
    methodValue.Call(args)
}

結構體中Tag標簽

結構體中的字段除了有名字和類型外，還可以有一個可選的標簽。它是一個附屬於字段的字符串，可以是文檔或其它的重要標記。標簽的內容不可以在一般的編程中使用，只有包reflect能獲取它。reflect包可以在運行時自省類型、屬性和方法，比如在一個變量上調用reflect.TypeOf()可以獲取變量的正確類型，如果變量是一個結構體類型，就可以通過Field來索引結構體的字段，然後就可以使用Tag屬性

import (
    "reflect"
    "fmt"
)

type User struct { // tags
    Id int64   `json:"id"`
    Name string `json:"name"`
    Gender bool    `json:"gender"`
}

func main() {
    tt := User{10001, "Barak Obama", true}
    value := reflect.ValueOf(tt)
    for i := 0; i < value.NumField(); i++ {
        ttType := reflect.TypeOf(tt)
        ixField := ttType.Field(i)
        fmt.Printf("%v\n", ixField.Tag.Get("json"))
    }
}

Go reflect反射