2019独角兽企业重金招聘Python工程师标准>>> 
What you are wasting today is tomorrow for those who died yesterday; what you hate now is the future you can not go back.
你所浪费的今天是昨天死去的人奢望的明天； 你所厌恶的现在是未来的你回不去的曾经。
Go是静态类型语言。每个变量都拥有一个静态类型，这意味着每个变量的类型在编译时都是确定的：int，float32, *AutoType, []byte, chan []int 诸如此类。
动静类型
编译时就知道变量类型的是静态类型；运行时才知道一个变量类型的叫做动态类型。
1. 静态类型
静态类型就是变量声明时的赋予的类型。比如：
type MyInt int // int 就是静态类型
type A struct{
Name string // string就是静态
}
var i *int // *int就是静态类型2. 动态类型
动态类型：运行时给这个变量复制时，这个值的类型(如果值为nil的时候没有动态类型)。一个变量的动态类型在运行时可能改变，这主要依赖于它的赋值（前提是这个变量时接口类型）。
var A interface{} // 静态类型interface{}
A = 10 // 静态类型为interface{} 动态为int
A = "String" // 静态类型为interface{} 动态为string
var M *int
A = M // 猜猜这个呢？来看看这个例子：
//定义一个接口
type Abc interface{
String() string
}
// 类型
type Efg struct{
data string
}
// 类型Efg实现Abc接口
func (e *Efg)String()string{
return e.data
}
// 获取一个*Efg实例
func GetEfg() *Efg{
return nil
}
// 比较
func CheckAE(a Abc) bool{
return a == nil
}
func main() {
efg := GetEfg()
b := CheckAE(efg)
fmt.Println(b)
os.Exit(1)
｝关于动静态类型就到这里，详细请自行Google，百度吧。
反射
那么什么时候下使用反射呢？
有时候你想在运行时使用变量来处理变量，这些变量使用编写程序时不存在的信息。也许你正试图将来自文件或网络请求的数据映射到变量中。也许创建一个适用于不同类型的tool。在这些情况下，你需要使用反射。反射使您能够在运行时检查类型。它还允许您在运行时检查，修改和创建变量，函数和结构。
类型
你可以使用反射来获取变量的类型： var t := reflect.Typeof(v)。返回值是一个reflect.Type类型。该值有很多定义好的方法可以使用。
Name()
返回类型的名称。 但是像切片或指针是没有类型名称的，只能返回空字符串。
Kind()
Kind有slice, map , pointer指针，struct, interface, string , Array, Function, int或其他基本类型组成。Kind和Type之前要做好区分。如果你定义一个 type Foo struct {}， 那么Kind就是struct, Type就是Foo。
*小知识点：反射变量对应的Kind方法的返回值是基类型，并不是静态类型。下面的例子中：
type MyInt int
var x MyInt = 7
v := reflect.ValueOf(x)变量v的Kind依旧是reflect.Int，而不是MyInt这个静态类型。Type可以表示静态类型，而Kind不可以。
*注意点： 在使用refelct包时， reflect包会假定你已经知道所做的是什么，否则引发panic。 例如你调用了与当前reflect.Type 不同的类型上的方法，那么就会引发panic。
Elem()
如果你的变量是一个指针、map、slice、channel、Array。那么你可以使用reflect.Typeof(v).Elem()来确定包含的类型。
案例代码
type Foo struct {
A int `tag1:"Tag1" tag2:"Second Tag"`
B string
}
func main(){
// Struct
f := Foo{A: 10, B: "Salutations"}
// Struct类型的指针
fPtr := &f
// Map
m := map[string]int{"A": 1 , "B":2}
// channel
ch := make(chan int)
// slice
sl:= []int{1,32,34}
//string
str := "string var"
// string 指针
strPtr := &str
tMap := examiner(reflect.TypeOf(f), 0)
tMapPtr := examiner(reflect.TypeOf(fPtr), 0)
tMapM := examiner(reflect.TypeOf(m), 0)
tMapCh := examiner(reflect.TypeOf(ch), 0)
tMapSl := examiner(reflect.TypeOf(sl), 0)
tMapStr := examiner(reflect.TypeOf(str), 0)
tMapStrPtr := examiner(reflect.TypeOf(strPtr), 0)
fmt.Println("tMap :", tMap)
fmt.Println("tMapPtr: ",tMapPtr)
fmt.Println("tMapM: ",tMapM)
fmt.Println("tMapCh: ",tMapCh)
fmt.Println("tMapSl: ",tMapSl)
fmt.Println("tMapStr: ",tMapStr)
fmt.Println("tMapStrPtr: ",tMapStrPtr)
}
// 类型以及元素的类型判断
func examiner(t reflect.Type, depth int) map[int]map[string]string{
outType := make(map[int]map[string]string)
// 如果是一下类型，重新验证
switch t.Kind() {
case reflect.Array, reflect.Chan, reflect.Map, reflect.Ptr, reflect.Slice:
fmt.Println("这几种类型Name是空字符串：",t.Name(), ", Kind是：", t.Kind())
// 递归查询元素类型
tMap := examiner(t.Elem(), depth)
for k, v := range tMap{
outType[k] = v
}
case reflect.Struct:
for i := 0; i < t.NumField(); i++ {
f := t.Field(i) // reflect字段
outType[i] = map[string]string{
"Name":f.Name,
"Kind":f.Type.String(),
}
}
default:
// 直接验证类型
outType = map[int] map[string]string{depth:{"Name":t.Name(), "Kind":t.Kind().String()}}
}
return outType
}运行结果：
其中t.Field(index) 必须使用在Struct上 , 所以，细读文档才行
利用反射读取，设置，创建
看完了上面关于reflect检测变量类型外，我们使用反射读取、设置和创建。
要想读取一个变量的值，首先需要一个reflect.Valueof( var ) 实例（reflectVal := reflect.Valueof(var)）， 同时也可以获取变量的类型了。
要想修改一个变量的值，那么必须通过该变量的指针地址 , 取消指针的引用 。通过refPtrVal := reflect.Valueof( &var )的方式获取指针类型，你使用refPtrVal.elem( ).set（一个新的reflect.Value）来进行更改，传递给set（）的值也必须是一个reflect.value。
要想创建一个值，那么使用NewPtrVal := reflect.New( vartype ) 传递一个reflect.Type类型。 返回的指针类型就可以使用以上修改的方式写入值。
最后，你可以通过调用interface（）方法返回一个正常的变量。因为Golang没有泛型，变量的原始类型丢失;该方法返回一个类型为interface{} 的值。如果创建了一个指针以便可以修改该值，则需要使用elem（）.interface（）来反引用reflect的指针。在这两种情况下，您都需要将空接口转换为实际类型才能使用它。
实例代码：
type Foo struct {
A int `tag1:"Tag1" tag2:"Second Tag"`
B string
}
func main(){
// 反射的使用
s := "String字符串"
fo := Foo{A: 10, B: "字段String字符串"}
sVal := reflect.ValueOf(s)
// 在没有获取指针的前提下，我们只能读取变量的值。
fmt.Println(sVal.Interface())
sPtr := reflect.ValueOf(&s)
sPtr.Elem().Set(reflect.ValueOf("修改值1"))
sPtr.Elem().SetString("修改值2")
// 修改指针指向的值，原变量改变
fmt.Println(s)
fmt.Println(sPtr) // 要注意这是一个指针变量，其值是一个指针地址
foType := reflect.TypeOf(fo)
foVal := reflect.New(foType)
// foVal.Elem().Field(0).SetString("A") // 引发panic
foVal.Elem().Field(0).SetInt(1)
foVal.Elem().Field(1).SetString("B")
f2 := foVal.Elem().Interface().(Foo)
fmt.Printf("%+v, %d, %s\n", f2, f2.A, f2.B)
｝运行结果：
记忆10秒。
创建slice, map, chan
除了创建内置和用户定义类型的实例之外，还可以使用反射来创建通常需要make功能的实例。使用reflect.Makeslice，reflect.Makemap和reflect.Makechan函数来制作slice，map或channel。
// 反射创建map slice channel
intSlice := make([]int, 0)
mapStringInt := make(map[string]int)
sliceType := reflect.TypeOf(intSlice)
mapType := reflect.TypeOf(mapStringInt)
// 创建新值
intSliceReflect := reflect.MakeSlice(sliceType, 0, 0)
mapReflect := reflect.MakeMap(mapType)
// 使用新创建的变量
v := 10
rv := reflect.ValueOf(v)
intSliceReflect = reflect.Append(intSliceReflect, rv)
intSlice2 := intSliceReflect.Interface().([]int)
fmt.Println(intSlice2)
k := "hello"
rk := reflect.ValueOf(k)
mapReflect.SetMapIndex(rk, rv)
mapStringInt2 := mapReflect.Interface().(map[string]int)
fmt.Println(mapStringInt2)运行结果：
创建函数
使用reflect.Makefunc()创建，这个函数需要我们想要做的函数的reflect.type和一个输入参数是[] reflect.value类型的slice，其输出参数也是类型[] reflect.value的闭包。下面是一个简单的例子，检测任意给定函数的执行时长：
package main
import (
"reflect"
"time"
"fmt"
"runtime"
)
/*
将创建Func封装， 非reflect.Func类型会panic
当然makeFunc的闭包函数表达式类型是固定的，可以查阅一下文档。
细读文档的reflect.Value.Call()方法。
*/
func MakeTimedFunction(f interface{}) interface{} {
rf := reflect.TypeOf(f)
if rf.Kind() != reflect.Func {
panic("非Reflect.Func")
}
vf := reflect.ValueOf(f)
wrapperF := reflect.MakeFunc(rf, func(in []reflect.Value) []reflect.Value {
start := time.Now()
out := vf.Call(in)
end := time.Now()
fmt.Printf("calling %s took %v\n", runtime.FuncForPC(vf.Pointer()).Name(), end.Sub(start))
return out
})
return wrapperF.Interface()
}
func time1() {
fmt.Println("time1Func===starting")
time.Sleep(1 * time.Second)
fmt.Println("time1Func===ending")
}
func time2(a int) int {
fmt.Println("time2Func===starting")
time.Sleep(time.Duration(a) * time.Second)
result := a * 2
fmt.Println("time2Func===ending")
return result
}
func main() {
timed := MakeTimedFunction(time1).(func())
timed()
timedToo := MakeTimedFunction(time2).(func(int) int)
time2Val := timedToo(5)
fmt.Println(time2Val)
}运行结果：
分析：
reflect.Value.Call(var) 文档如下：
扩展Call()
首先我们可以确认一点就是，函数像普通变量一样， 假如Foo()是一个函数， 那么,f := Foo 也是成立的。
在反射中 函数 和 方法 的类型（Type）都是 reflect.Func，如果要调用函数的话，可以通过 Value 的 Call() 方法，例如：
func Halou(){
fmt.Println("This is Halou函数！ 6666")
}
func main(){
// Call()扩展
h := Halou
hVal := reflect.ValueOf(h)
fmt.Println("hVal is reflect.Func ?", hVal.Kind() == reflect.Func)
hVal.Call(nil)
｝运行结果：
reflect.Value 的 Call() 方法的参数是一个 reflect.Value 的 slice，对应所反射函数类型的参数，返回值也是一个 reflect.Value 的 slice，同样对应所反射函数类型的返回值。所以：
func Halou2(s string)string{
return "接受到参数："+s+", 但这是返回值！"
}
func main(){
h2 := reflect.ValueOf(Halou2)
params := []reflect.Value{
reflect.ValueOf("参数1"),
}
h2ReturnVal := h2.Call(params)
fmt.Println(h2ReturnVal)
｝留下个问题吧！
函数本事独立与任何个体之外存活的，方法却要依托对象的存在。方法是“对象”的一种行为。那么如何通过反射调用方法呢？