Go通关08：断言、反射的理解与使用！

//非安全类型断言
<目标类型的值> := <表达式>.( 目标类型 )
// 安全类型断言
<目标类型的值>，<布尔参数> := <表达式>.( 目标类型 )

package main
import "fmt"

func whoAmi(a interface{}) {
    //1.不断言
    //程序报错：cannot convert a (type interface{}) to type string: need type assertion
    //fmt.Println(string(a)) 
  
    //2.非安全类型断言
    //fmt.Println(a.(string)) //无尘
  
    //3.安全类型断言
    value, ok := a.(string) //安全，断言失败，也不会panic，只是ok的值为false
    if !ok {
      fmt.Println("断言失败")
      return
    }
    fmt.Println(value)  //无尘
}
func main() {
    str := "无尘"
    whoAmi(str)
}

func whoAmi(a interface{}) {
    switch a.(type) {
    case bool:
  fmt.Printf("boolean: %t\n", a) // a has type bool
    case int:
  fmt.Printf("integer: %d\n", a) // a has type int
    case string:
  fmt.Printf("string: %s\n", a) // a has type string
    default:
    fmt.Printf("unexpected type %T", a) // %T prints whatever type a has
    }
}

package main
import (
  "fmt"
  "reflect"
)
func main() {
  var name string = "微客鸟窝"
  // TypeOf会返回变量的类型，比如int/float/struct/指针等
 reflectType := reflect.TypeOf(name)

 // valueOf返回变量的的值，此处为"微客鸟窝"
 reflectValue := reflect.ValueOf(name)

 fmt.Println("type: ", reflectType) //type:  string
 fmt.Println("value: ", reflectValue) //value:  微客鸟窝
}

type Type interface {
    // 所有的类型都可以调用下面这些函数

    // 此类型的变量对齐后所占用的字节数
    Align() int
    
    // 如果是 struct 的字段，对齐后占用的字节数
    FieldAlign() int

    // 返回类型方法集里的第 `i` (传入的参数)个方法
    Method(int) Method

    // 通过名称获取方法
    MethodByName(string) (Method, bool)

    // 获取类型方法集里导出的方法个数
    NumMethod() int

    // 类型名称
    Name() string

    // 返回类型所在的路径，如：encoding/base64
    PkgPath() string

    // 返回类型的大小，和 unsafe.Sizeof 功能类似
    Size() uintptr

    // 返回类型的字符串表示形式
    String() string

    // 返回类型的类型值
    Kind() Kind

    // 类型是否实现了接口 u
    Implements(u Type) bool

    // 是否可以赋值给 u
    AssignableTo(u Type) bool

    // 是否可以类型转换成 u
    ConvertibleTo(u Type) bool

    // 类型是否可以比较
    Comparable() bool

    // 下面这些函数只有特定类型可以调用
    // 如：Key, Elem 两个方法就只能是 Map 类型才能调用
    
    // 类型所占据的位数
    Bits() int

    // 返回通道的方向，只能是 chan 类型调用
    ChanDir() ChanDir

    // 返回类型是否是可变参数，只能是 func 类型调用
    // 比如 t 是类型 func(x int, y ... float64)
    // 那么 t.IsVariadic() == true
    IsVariadic() bool

    // 返回内部子元素类型，只能由类型 Array, Chan, Map, Ptr, or Slice 调用
    Elem() Type

    // 返回结构体类型的第 i 个字段，只能是结构体类型调用
    // 如果 i 超过了总字段数，就会 panic
    Field(i int) StructField

    // 返回嵌套的结构体的字段
    FieldByIndex(index []int) StructField

    // 通过字段名称获取字段
    FieldByName(name string) (StructField, bool)

    // FieldByNameFunc returns the struct field with a name
    // 返回名称符合 func 函数的字段
    FieldByNameFunc(match func(string) bool) (StructField, bool)

    // 获取函数类型的第 i 个参数的类型
    In(i int) Type

    // 返回 map 的 key 类型，只能由类型 map 调用
    Key() Type

    // 返回 Array 的长度，只能由类型 Array 调用
    Len() int

    // 返回类型字段的数量，只能由类型 Struct 调用
    NumField() int

    // 返回函数类型的输入参数个数
    NumIn() int

    // 返回函数类型的返回值个数
    NumOut() int

    // 返回函数类型的第 i 个值的类型
    Out(i int) Type

    // 返回类型结构体的相同部分
    common() *rtype
    
    // 返回类型结构体的不同部分
    uncommon() *uncommonType
}

// 设置切片的 len 字段，如果类型不是切片，就会panic
 func (v Value) SetLen(n int)
 
 // 设置切片的 cap 字段
 func (v Value) SetCap(n int)
 
 // 设置字典的 kv
 func (v Value) SetMapIndex(key, val Value)

 // 返回切片、字符串、数组的索引 i 处的值
 func (v Value) Index(i int) Value
 
 // 根据名称获取结构体的内部字段值
 func (v Value) FieldByName(name string) Value
 
 // ……

package main

import (
   "fmt"
   "reflect"
)

type Address struct {
 City string
}

type Person struct {
 Name string
 Age uint
 Address // 匿名字段
}

func (p Person) Hello(){
   fmt.Println("我是无尘啊")
}

func main() {
   //p := Person{Name:"无尘",Age:18,Address:Address{City:"北京"}}  //map形式初始化
   p := Person{"无尘",18,Address{"北京"}}

   // 获取目标对象
   t := reflect.TypeOf(p)
   fmt.Println("t:", t)
 
   // .Name()可以获取去这个类型的名称
   fmt.Println("类型的名称:", t.Name())

   // 获取目标对象的值类型
   v := reflect.ValueOf(p)
   fmt.Println("v:", v)
   
   // .NumField()获取其包含的字段的总数
   for i := 0; i < t.NumField(); i++ {
     // 从0开始获取Person所包含的key
     key := t.Field(i)
     // interface方法来获取key所对应的值
     value := v.Field(i).Interface()
     fmt.Printf("第%d个字段是：%s:%v = %v \n", i+1, key.Name, key.Type, value)
   }
   // 取出这个City的详情打印出来
   fmt.Printf("%#v\n", t.FieldByIndex([]int{2, 0}))
   // .NumMethod()来获取Person里的方法
   for i:=0;i<t.NumMethod(); i++ {
     m := t.Method(i)
     fmt.Printf("第%d个方法是：%s:%v\n", i+1, m.Name, m.Type)
   }
}

t: main.Person
类型的名称: Person
v: {无尘 18 {北京}}
第1个字段是：Name:string = 无尘 
第2个字段是：Age:uint = 18 
第3个字段是：Address:main.Address = {北京} 
reflect.StructField{Name:"City", PkgPath:"", Type:(*reflect.rtype)(0x4cfe60), Tag:"", Offset:0x0, Index:[]int{0}, Anonymous:false}
第1个方法是：Hello:func(main.Person)

package main

import (
 "reflect"
 "fmt"
)

type Person struct {
 Name string
 Age int
}

func main() {
 p := &Person{"无尘",18}
 v := reflect.ValueOf(p)

 // 修改值必须是指针类型
 if v.Kind() != reflect.Ptr {
  fmt.Println("非指针类型，不能进行修改")
  return
 }

 // 获取指针所指向的元素
 v = v.Elem()
 // 获取目标key的Value的封装
 name := v.FieldByName("Name")

 if name.Kind() == reflect.String {
  name.SetString("wucs")
 }

 fmt.Printf("%#v \n", *p)


 // 如果是整型的话
 test := 666
 testV := reflect.ValueOf(&test)
 testV.Elem().SetInt(999)
 fmt.Println(test)
}

main.Person{Name:"wucs", Age:18} 
999

package main

import (
 "fmt"
 "reflect"
)

type Person struct {
 Name string
 Age int
}

func (p Person) EchoName(name string){
 fmt.Println("我的名字是：", name)
}

func main() {
 p := Person{Name: "无尘",Age: 18}

 v := reflect.ValueOf(p)

 // 获取方法控制权
 // 官方解释：返回v的名为name的方法的已绑定（到v的持有值的）状态的函数形式的Value封装
 mv := v.MethodByName("EchoName")
 // 拼凑参数
 args := []reflect.Value{reflect.ValueOf("wucs")}

 // 调用函数
 mv.Call(args)
}

我的名字是：wucs