注意：反射获取字段给字段赋值时，该字段必须首字母大写，否则会引起恐慌报如下错误：
    panic: reflect: reflect.flag.mustBeAssignable using value obtained using unexported field

    1.变量结构
    type,value（pair）

    2.reflect包
    1.reflect类型

    1. const (
    2.     Invalid Kind = iota //0~26
    3.     Bool
    4.     Int
    5.     Int8
    6.     Int16
    7.     Int32
    8.     Int64
    9.     Uint
    10.     Uint8
    11.     Uint16
    12.     Uint32
    13.     Uint64
    14.     Uintptr
    15.     Float32
    16.     Float64
    17.     Complex64
    18.     Complex128
    19.     Array
    20.     Chan
    21.     Func
    22.     Interface
    23.     Map
    24.     Ptr
    25.     Slice
    26.     String
    27.     Struct
    28.     UnsafePointer //26
    29. )

    2.获取kind

    1. package main
    3. import "reflect"
    5. type User struct {
    6.     Name string
    7.     Age  int
    8. }
    10. func refTest(arg interface{}) {
    11.     var argType reflect.Type = reflect.TypeOf(arg)
    12.     var argValue reflect.Value = reflect.ValueOf(arg)
    13.     print(argType.Kind())
    14.     print(argValue.Kind())
    15. }
    17. func main() {
    18.     refTest(User{"zhangsna", 11})
    19.     //25  struct类型
    20. }

    3.获取属性

    1. package main
    3. import (
    4.     "fmt"
    5.     "reflect"
    6. )
    8. type User struct {
    9.     //定义字段，并设置字段标签
    10.     Name   string  `info:"名字" doc:"哈哈"`
    11.     Age    int     `info:"年龄"`
    12.     height float64 `info:"身高"`
    13. }
    15. func (user *User) GetName() string {
    16.     return user.Name
    17. }
    19. //interface{}是万能数据类型
    20. func myFunc(arg interface{}) {
    21.     //通过参数获取，参数的类型和值
    22.     argType := reflect.TypeOf(arg)
    23.     argValue := reflect.ValueOf(arg)
    24.     //当arg是pir时，需要通过argType.Elem()获取属性，例如argType.Elem().NumField()
    25.     for i := 0; i < argType.NumField(); i++ {
    26.         //通过type获取内部字段类型和值
    27.         field := argType.Field(i)
    28.         value := argValue.Field(i)
    29.         fmt.Println(field.Name, field.Type, value)
    30.         //获取字段标签,Tag只存在类型里
    31.         info := argType.Field(i).Tag.Get("info")
    32.         doc := argType.Field(i).Tag.Get("doc")
    33.         fmt.Println("标签info为：", info, "doc为", doc)
    34.     }
    36.     //通过type获取内部方法,只能获取非地址传值的方法
    37.     for i := 0; i < argType.NumMethod(); i++ {
    38.         method := argType.Method(i)
    39.         fmt.Println(method.Name, method.Type)
    40.     }
    42. }
    44. func main() {
    45.     user := User{"张三", 24, 1.70}
    46.     myFunc(user)
    47. }

    4.反射修改值

    1. package main
    3. import (
    4.     "fmt"
    5.     "reflect"
    6. )
    8. func refTest(arg interface{}) {
    9.     argValue := reflect.ValueOf(arg)
    10.     argValue.Elem().SetInt(10)
    11. }
    13. func main() {
    14.     var a int = 11
    15.     //必须传递指针
    16.     refTest(&a)
    17.     fmt.Println(a)
    18. }

    5.反射调用方法