反射初识
package main
import (
"fmt"
"reflect"
)
//23
func main() {
/*
反射操作：通过反射，可以获取一个接口类型变量的 类型和数值
*/
var x float64 = 3.14
fmt.Println("type:",reflect.TypeOf(x)) //type: float64
fmt.Println("value:",reflect.ValueOf(x)) //value: 3.14
//根据反射的值，来获取对应的类型和数值
v := reflect.ValueOf(x)
fmt.Println("kind is float64:",v.Kind() == reflect.Float64) //kind is float64: true
fmt.Println("type:",v.Type()) //type: float64
fmt.Println("value:",v.Float()) //value: 3.14
}
reflect对象获取接口变量信息
package main
import (
"fmt"
"reflect"
)
//24
func main() {
/*
反射操作：通过反射，可以获取一个接口类型变量的 类型和数值
*/
var num float64 = 1.23
value := reflect.ValueOf(num)
convertValue := value.Interface().(float64)
fmt.Println(convertValue) //1.23
/*
反射类型对象 --> 接口类型变量，理解为"强制转换"
Golang对类型要求非常严格，类型一定要完全符合
一个是*float64，一个是float64，混淆就会panic
*/
pointer := reflect.ValueOf(&num)
convertpointer := pointer.Interface().(*float64)
fmt.Println(convertpointer) //0xc0000b4008
p1 := Person{"王二狗",18,"男"}
GetMessage(p1)
}
func GetMessage(input interface{}){
getType := reflect.TypeOf(input)
fmt.Println("get Type is : ",getType.Name()) //get Type is : Person
fmt.Println("get Kind is : ",getType.Kind()) //get Kind is : struct
getValue := reflect.ValueOf(input)
fmt.Println("get all Fields is :",getValue) //get all Fields is : {王二狗 18 男}
//获取字段
/*
1。 获取Type对象：reflect.Type
NumField()
Field(index)
2。通过Field()获得每一个Field字段
3。 Interface()，得到对应的Value
*/
for i := 0; i < getType.NumField(); i++ {
field := getType.Field(i)
value := getValue.Field(i).Interface()
//字段名称:Name,字段类型：string，字段数值：王二狗
//字段名称:Age,字段类型：int，字段数值：18
//字段名称:Sex,字段类型：string，字段数值：男
fmt.Printf("字段名称:%s,字段类型：%s，字段数值：%v\n",field.Name,field.Type,value)
}
//获取方法
for i := 0; i < getType.NumMethod(); i++ {
method := getType.Method(i)
//方法名称：PrintInfo，方法类型：func(main.Person)
//方法名称：Say，方法类型：func(main.Person, string)
fmt.Printf("方法名称：%s，方法类型：%v\n",method.Name,method.Type)
}
}
type Person struct {
Name string
Age int
Sex string
}
func (p Person) Say(msg string) {
fmt.Println("hello",msg)
}
func (p Person) PrintInfo() {
fmt.Println("姓名：%s，年龄：%d，性别：%s\n",p.Name,p.Age,p.Sex)
}
reflect对象设置实际变量的值
package main
import (
"fmt"
"reflect"
)
//25
func main() {
/*
反射操作：通过反射，可以获取一个接口类型变量的 类型和数值
*/
var num float64 = 1.23
//需要操作指针
//通过reflect.ValueOf() 获得num的value对象
pointer := reflect.ValueOf(&num) //注意参数必须是指针才能修改其值
newValue := pointer.Elem()
fmt.Println("类型：",newValue.Type()) //类型： float64
fmt.Println("是否可以修改:",newValue.CanSet()) //是否可以修改: true
//重新赋值
newValue.SetFloat(3.14)
fmt.Println(num) //3.14
s1 := Student{"suntong",22}
fmt.Printf("%T\n",s1) //main.Student
//反射改变数值
value := reflect.ValueOf(&s1)
if value.Kind() == reflect.Ptr {
newValue2 := value.Elem()
fmt.Println(newValue2) //{suntong 22}
f1 := newValue2.FieldByName("Name")
f1.SetString("zhangsan")
fmt.Println(s1) //{zhangsan 22}
}
}
type Student struct {
Name string
Age int
}
reflect对象进行方法的调用
package main
import (
"fmt"
"reflect"
"strconv"
)
//26
func main() {
/*
通过反射来进行方法的调用
思路：
1。 接口变量 -> 对象反射对象：Value
2. 获取对应的方法对象，MethodByName()
3. 将方法对象进行调用，Call()
*/
p1 := Person2{"suntong",22,"男"}
value := reflect.ValueOf(p1)
fmt.Printf("kind:%s,type:%s\n",value.Kind(),value.Type()) //kind:struct,type:main.Person2
methodValue1 := value.MethodByName("PrintInfo")
//kind:func,type:func()
fmt.Printf("kind:%s,type:%s\n",methodValue1.Kind(),methodValue1.Type())
//没有参数，进行调用
methodValue1.Call(nil) //姓名：suntong，年龄：22，性别：男
args1 := make([]reflect.Value,0) //空切片
methodValue1.Call(args1) //姓名：suntong，年龄：22，性别：男
methodValue2 := value.MethodByName("Say")
// kind:func,type:func(string)
fmt.Printf("kind:%s,type:%s\n",methodValue2.Kind(),methodValue2.Type())
args2 := []reflect.Value{reflect.ValueOf("反射机制")} //多个参数，增加reflect.ValueOf(int/string。。。)
methodValue2.Call(args2) //hello 反射机制
//函数的反射
f5 := fun5
value1 := reflect.ValueOf(f5)
fmt.Printf("kind:%s,type:%s\n",value1.Kind(),value1.Type()) //kind:func,type:func()
value2 := reflect.ValueOf(fun6)
value3 := reflect.ValueOf(fun7)
fmt.Printf("kind:%s,type:%s\n",value2.Kind(),value2.Type()) //kind:func,type:func(int, string)
fmt.Printf("kind:%s,type:%s\n",value3.Kind(),value3.Type()) //kind:func,type:func(int, string) string
//通过反射调用函数
//fun5,无参
//fun6,有参
//fun5,有参有返回值
value1.Call(nil)
value2.Call([]reflect.Value{reflect.ValueOf(1000),reflect.ValueOf("suntong")})
resultValue := value3.Call([]reflect.Value{reflect.ValueOf(2000),reflect.ValueOf("isuntong")})
fmt.Printf("%T\n",resultValue) //[]reflect.Value
fmt.Println(len(resultValue)) //1
fmt.Printf("kind:%s,type:%s\n",resultValue[0].Kind(),resultValue[0].Type()) //kind:string,type:string
s := resultValue[0].Interface().(string)
fmt.Println(s) //isuntong2000
fmt.Printf("%T\n",s) //string
}
func fun5(){
fmt.Println("fun5,无参")
}
func fun6(i int,s string){
fmt.Println("fun6,有参")
}
func fun7(i int,s string)(string){
fmt.Println("fun5,有参有返回值")
return s + strconv.Itoa(i)
}
type Person2 struct {
Name string
Age int
Sex string
}
func (p Person2) Say(msg string) {
fmt.Println("hello",msg)
}
func (p Person2) PrintInfo() {
fmt.Printf("姓名：%s，年龄：%d，性别：%s\n",p.Name,p.Age,p.Sex)
}
