golang基础--reflect反射

反射可达大提高程序的灵活性，使得inferface{}有更大的发挥余地

反射使用TypeOf和ValueOf函数从接口中获取目标对象信息:字段属性，方法信息

package main
import (
    "fmt"
    "reflect"
)
type User struct { //定义一个结构类型
    Id   int
    Name String
    Age  int
}

func (u User) Hello() { //定义一个结构方法
    fmt.Println("Hello world")
}

func Info(o interface{}) { //定义一个方法，参数为空接口
    t := reflect.TypeOf(o)         //获取接收到的接口类型
    fmt.Println("Type:",t.Name()) //获取名称

    v := reflect.ValueOf(o) //获取接口的字段
    fmt.Println("Fields:")

    //获取结构字段
    for i := 0; i < t.NumField(); i++ { //for循环，取出所拥有的字段
        f := t.Field(i)               //获取值字段
        val := v.Field(i).Interface() //获取字段的值
        fmt.Printf("%6s:%v=%v\n",f.Name,f.Type,val)
    }
    //通过接口获取结构的方法
    for i := 0; i < t.NumMethod(); i++ {
        m := t.Method(i)
        fmt.Printf("%6s:%v\n",m.Name,m.TypE)
    }

}

func main() {
    u := User{1,"OK",12} //实例化一个结构
    Info(u)                //调用Info函数

}

/*输出
    Type: User
    Fields:
        Id:int=1
      Name:string=OK
       Age:int=12
    Hello:func(main.User)
*/

反射会将匿名字段作为独立字段（匿名字段本质）

package main
import (
    "fmt"
    "reflect"
)

type User struct { //定义一个结构类型
    Id   int
    Name String
    Age  int
}

type Manager struct {
    User  //嵌入User结构，User就是Manager结构的匿名字段
    title String
}

func main() {
    m := Manager{User: User{1,"mm",27},title: "name"} //注意初始化方式
    t := reflect.TypeOf(m)                               //传递结构

    fmt.Printf("%#v\n",t.Field(0))                  //获取索引为0的字段信息，即User字段信息
    fmt.Printf("%#v\n",t.FieldByIndex([]int{0,0})) //根据索引取出ID的字段信息（）
} //{0，0}--User在Manager索引为0，ID在User索引为0

/*output
    reflect.StructField{name:"User",PkgPath:"",Type:(*reflect.rtypE)(0x4ac220),Tag:"",Offset:0x0,Index:[]int{0},Anonymous:truE}

"Anonymous:true" 其中包含anonymous（匿名）字段
*/

想要利用反射修改对象状态，前提是interface.data是settable,即pointer-interface(指针接口)

• 示例1

//这是一个简单的修改对象状态
package main
import (
    "fmt"
    "reflect"
)

func main() {
    x := 123                    //底层类型是int类型
    v := reflect.ValueOf(&X)    //传递x的指针 
    v.Elem().SeTint(999)        //通过方法修改x变量的值

    fmt.Println(X)
}

/*输出
x--->  999
*/

• 示例2

//通过反射修改结构字段
package main
import (
    "fmt"
    "reflect"
)

type User struct {
    Name String
    ID   int
    Age  int
}

func main() {
    u := User{"MAOZI",1,22}
    Set(&u)
    fmt.Println(u)

}

func Set(o interface{}) {
    v := reflect.ValueOf(o)

    if v.Kind() != reflect.Ptr && !v.Elem().CanSet() { //判断是否为反射typeString,且可以被修改
        fmt.Println("fuck")
        return
    } else { //如果条件都满足
        v = v.Elem()
    }

    f := v.FieldByName("Name") //通过名字段名找字段
    if !f.IsValid() {          //IsValid方法判断是否找了字段
        fmt.Println("invalid")
        return
    }
    if f.Kind() == reflect.String {
        f.SetString("momo")
    }

}

/*输出
{momo 1 22}
*/

通过反射可以"动态"调用方法

//通过反射动态调用结构方法
package main
import (
    "fmt"
    "reflect"
)

type User struct {
    Name String
    ID   int
    Age  int
}

func (u User) Hello(name String) {
    fmt.Println("Hello",name,",my name is",u.Name)

}
func main() {
    u := User{"Golang",22}
    v := reflect.ValueOf(u)
    mv := v.MethodByName("Hello") //反射：通过名字找结构字段信息

    args := []reflect.Value{reflect.ValueOf("Python")}
    mv.Call(args)

}

/*输出
Hello Python,my name is Golang
*/