1. 反射

反射這個概念絕大多數(shù)語言都有糠爬，比如Java，PHP之類举庶，golang自然也不例外执隧，反射其實(shí)程序能夠自描述和自控制的一類機(jī)制。
比如，通過PHP的反射殴玛，你可以知道一個類有什么成員捅膘，有什么方法。而golang滚粟，也能夠通過官方自帶的reflect包來了解各種變量類型及其信息寻仗。
下面我們通過一個例子查看反射的基本用法。

話不多說凡壤，直接貼代碼：

package main

import (
    "fmt"
    "reflect"
)

type Order struct {
    ordId      int  `json:"order_id" validate:"required"`
    customerId string   `json:"customer_id" validate:"required"`
    callback func() `json:"call_back" validate:"required"`
}

func reflectInfo(q interface{}) {
    t := reflect.TypeOf(q)
    v := reflect.ValueOf(q)
    fmt.Println("Type ", t)
    fmt.Println("Value ", v)
    for i := 0; i < v.NumField(); i = i + 1 {
        fv := v.Field(i)
        ft := t.Field(i)
        tag := t.Field(i).Tag.Get("json")
        validate := t.Field(i).Tag.Get("validate")
        switch fv.Kind() {
        case reflect.String:
            fmt.Printf("The %d th %s types: %s, valuing: %s, struct tag: %v\n", i, ft.Name, "string", fv.String(), tag + " " + validate)
        case reflect.Int:
            fmt.Printf("The %d th %s types %s, valuing %d, struct tag: %v\n", i, ft.Name, "int", fv.Int(), tag + " " + validate)
        case reflect.Func:
            fmt.Printf("The %d th %s types %s, valuing %v, struct tag: %v\n", i, ft.Name, "func", fv.String(), tag + " " + validate)
        }
    }

}
func main() {
    o := Order{
        ordId:      456,
        customerId: "39e9e709-dd4f-0512-9488-a67c508b170f",
    }
    reflectInfo(o)
}

首先署尤，我們用reflect.TypeOf(q)和reflect.ValueOf(q)獲取了結(jié)構(gòu)體order的類型和值，然后我們再從循環(huán)里對它的成員進(jìn)行一個遍歷亚侠，并將所有成員的名稱和類型打印了出來曹体。這樣，一個結(jié)構(gòu)體的所有信息就都暴露在我們面前硝烂。

2.斷言

Go語言里面有一個語法箕别，可以直接判斷是否是該類型的變量： value, ok = element.(T)，這里value就是變量的值滞谢，ok是一個bool類型串稀，element是interface變量，T是斷言的類型狮杨。

如果element里面確實(shí)存儲了T類型的數(shù)值母截，那么ok返回true，否則返回false橄教。

package main

import (
    "fmt"
)

type Order struct {
    ordId      int
    customerId int
    callback func()
}

func main() {
    var i interface{}
    i = Order{
        ordId:      456,
        customerId: 56,
    }
    value, ok := i.(Order)
    if !ok {
        fmt.Println("It's not ok for type Order")
        return
    }
    fmt.Println("The value is ", value)
}

輸出：

The value is  {456 56 <nil>}

常見的還有用switch來斷言：

package main

import (
    "fmt"
)

type Order struct {
    ordId      int
    customerId int
    callback func()
}

func main() {
    var i interface{}
    i = Order{
        ordId:      456,
        customerId: 56,
    }
    switch value := i.(type) {
        case int:
            fmt.Printf("It is an int and its value is %d\n", value)
        case string:
            fmt.Printf("It is a string and its value is %s\n", value)
        case Order:
            fmt.Printf("It is a Order and its value is %v\n", value)
        default:
            fmt.Println("It is of a different type")
        }
}

輸出：

It is a Order and its value is {456 56 <nil>}