进一步有进一步惊喜

// kind处理不同分支
func printType(t reflect.Type) {
    switch t.Kind() {
    case reflect.Int:
        fmt.Println("int")
    case reflect.String:
        fmt.Println("string")
    }
}
func main() {
    a := 1
    t := reflect.TypeOf(a)
    printType(t)
    t = reflect.TypeOf("Hello World")
    printType(t)
}

// 需求:根据一个函数字符串，调用函数，提供函数参数,接收返回值
// 反射调用无参函数
// 反射调用有参无返回值函数
// 反射调用有入参和返回的函数
// 动态调用函数，无参数
type T struct{}
func (t *T) Do(){
    fmt.Println("Hello Do")
}
// 有参函数
func (t *T) Do2(a int,b string){
    fmt.Println("hello" + b,a)
}
func (t *T) Do3() (string,error){
    return "Hello",errors.New("return error")
}
func main() {
    // 函数名称
    name := "Do"
    t := &T{}
    // 反射调用函数
    reflect.ValueOf(t).MethodByName(name).Call(nil)
    // 反射调用有参函数
    a := reflect.ValueOf(111)
    b := reflect.ValueOf("world")
    in := []reflect.Value{a,b}
    reflect.ValueOf(t).MethodByName("Do2").Call(in)
    // 反射含有返回值的函数
    rets := reflect.ValueOf(t).MethodByName("Do3").Call(nil)
    fmt.Printf(" strValue:%[1]v \n errValue:%[2]v\n strType:%[1]T \n errType:%[2]T\n",
        rets[0],rets[1].Interface().(error))
}

// 反射解析struct 中的tag
//
//
type T struct {
    A int `json:"a" test:"testaa"`
    B string `json:"b" test:"testbb"`
}
func main() {
   t := T{
       A: 124,
       B: "Hello",
   }
   tt := reflect.TypeOf(t)
   for i:=0;i<tt.NumField();i++{
       field := tt.Field(i)
       
       // 输出json 的tag内容
       if json,ok := field.Tag.Lookup("json");ok{
           fmt.Printf("field: %s,testTag tag:%s\n",field.Name,json)
       }
       
       // 输出test的tag内容
       if testTag,ok := field.Tag.Lookup("test");ok{
           fmt.Printf("field: %s,testTag tag:%s \n",field.Name, testTag)
       }
   }
}

// 类型转换和赋值
// 将T1中的值赋值给tag为等于T2.
// T1.A -> T2.AA
// T1.B -> T2.BB
// 怎么知道T1.A对应T2.AA？
// T1中有一个tag为T2,值为AA
type T1 struct {
    A int `T2:"AA"`
    B string `T2:"BB"`
}
type T2 struct {
    AA int
    BB string
}
func main() {
    t := T1{
        A: 123,
        B: "hello",
    }
    rT1Type := reflect.TypeOf(t)
    rT1Value := reflect.ValueOf(t)
    
    t2 := &T2{}
    rT2Value := reflect.ValueOf(t2)
    
    // 赋值
    for i:=0;i< rT1Type.NumField();i++{
        field := rT1Type.Field(i)
        // 获得T1类型中的Tag的值为T2的Tag值
        newTTag := field.Tag.Get("T2")
        // 获得对应T1中对应Tag的值,为域值
        tValue := rT1Value.Field(i)
        // 给T2设置值
        rT2Value.Elem().FieldByName(newTTag).Set(tValue)
    }
    fmt.Println(t2)
}

// 动物接口
type Animal interface {
    speak()
}
type Cry interface {
    cry()
}
// 汽车实现speak()方法
type Car struct {

}
func (c *Car) speak() {
    fmt.Println("wu wu wu ...")
}
func main() {
    car := &Car{}
    rCarType := reflect.TypeOf(car)
    
    animalType := reflect.TypeOf((*Animal)(nil)).Elem()
    cryType := reflect.TypeOf((*Cry)(nil)).Elem()
    
    // 判断car是否实现了Animal接口
    re := rCarType.Implements(animalType)
    fmt.Println(re)
    // car 是否实现了Cry接口
    re = rCarType.Implements(cryType)
    fmt.Println(re)
}