复制到自己的编辑器, 从main函数看
package main
import (
"fmt"
"reflect"
)
func reflectTest01(b interface{}) {
//通过反射获取的传入的变量的 type , kind, 值
//1. 先获取到 reflect.Type
rtype := reflect.TypeOf(b)
fmt.Println(rtype)
//2. 获取到 reflect.Value
rval := reflect.ValueOf(b)
n2 := 2 + rval.Int()
fmt.Println("n2=", n2)
//下面我们将 rVal 转成 interface{}
iv := rval.Interface()
//将 interface{} 通过断言转成需要的类型
num2 := iv.(int)
fmt.Println("num2=", num2)
}
type Student struct {
Name string
Age int
}
func reflectTest02(b interface{}) {
//通过反射获取的传入的变量的 type , kind, 值
//1. 先获取到 reflect.Type
rtype := reflect.TypeOf(b)
fmt.Println(rtype)
//2. 获取到 reflect.Value
rval := reflect.ValueOf(b)
// 将 rVal 转成 interface{}
iv := rval.Interface()
fmt.Printf("iv=%v iv type=%T
", iv, iv)
// 使用类型推断将interface转换为需要的类型
stu, ok := iv.(Student)
if ok {
fmt.Printf("stu.name=%v
", stu.Name)
}
}
func reflectTest03(b interface{}) {
v1 := reflect.ValueOf(b)
fmt.Printf("val type=%T
", v1)
v1.Elem().SetInt(100) // 通过反射设置值
fmt.Printf("val=%v
", v1)
}
func reflectTest04(b interface{}) {
rtype := reflect.TypeOf(b) // main.Student
val := reflect.ValueOf(b) // { 0}
fmt.Printf("%v
", rtype)
fmt.Printf("%v
", val)
fmt.Printf("%v
", val.Kind()) // struct
v2 := val.Interface()
fmt.Printf("%v
", v2) // 将reflect.Value -> interface{}
v3, ok := v2.(float64) // 将interface{} -> float64
if ok {
fmt.Println(v3)
fmt.Printf("%v, %T", v3, v3)
}
}
type Monster struct {
Name string `json:"name"`
Age int `json:"age"`
Score float64 `json:"score"`
Sex string
}
func (this Monster) GetSum(n1, n2 int) int {
return n1 + n2
}
func (this Monster) Set(name string, age int, score float64, sex string) {
this.Name = name
this.Age = age
this.Score = score
this.Sex = sex
}
func (this Monster) Print() {
println("------start---------")
fmt.Println(this)
println("------end---------")
}
func reflectTest05(a interface{}) {
typ := reflect.TypeOf(a) // 获取类型
val := reflect.ValueOf(a) // 获取值
kd := val.Kind() // 获取kind
fmt.Println(kd, "---------------------------")
if kd != reflect.Struct {
fmt.Println("expect struct, actul is: ", kd)
return
}
num := val.NumField() // 获取字段数目
fmt.Printf("struct has %d files
", num)
// 遍历字段
for i := 0; i < num; i++ {
fmt.Printf("Filed %d: 值为=%v
", i, val.Field(i))
// 获取struct标签, 通过reflect.Type 来获取tag标签的值
tagVal := typ.Field(i).Tag.Get("json")
// 如果该字段于tag标签的显示, 否则就不显示
if tagVal != "" {
fmt.Printf("filed %d, tag为=%v
", i, tagVal)
}
}
// 获取结构的多少方法
numOfMethod := val.NumMethod()
fmt.Printf("struct had %d methods
", numOfMethod)
//var params []reflect.Value
//方法的排序默认是按照 函数名的排序（ASCII 码）
val.Method(1).Call(nil) // 获取第二个方法, 调用它
// 调用结构体的第一个方法 Method(0)
var params []reflect.Value
params = append(params, reflect.ValueOf(10))
params = append(params, reflect.ValueOf(40))
// 传入的参数是[]reflect.Value, 返回reflect.value
res := val.Method(0).Call(params)
fmt.Println("res=", res) // []reflect.value */
}
func reflectTest06(a interface{}) {
typ := reflect.TypeOf(a) // 获取类型
val := reflect.ValueOf(a) // 获取值
kd := val.Kind() // 获取kind
fmt.Println(kd, "---------------------------")
if kd != reflect.Struct {
fmt.Println("expect struct, actul is: ", kd)
return
}
num := typ.NumField() // 获取字段数目
fmt.Printf("struct has %d files
", num)
// 遍历字段
for i := 0; i < num; i++ {
filed := typ.Field(i)
value := val.Field(i).Interface()
fmt.Printf("%s: %v = %v
", filed.Name, filed.Type, value)
}
// 获取结构的多少方法
for i := 0; i < typ.NumMethod(); i++ {
m := typ.Method(i)
fmt.Printf("%s : %v
", m.Name, m.Type)
}
}
func test1() {
slice := []int{1, 2, 3, 4, 5}
m := make(map[int]int)
for key, val := range slice {
fmt.Println(key, val, &val)
m[key] = val
}
for key := range m {
// 都是5, 为什么?
// 可以理解为上面的val始终使用的是同一个地址, 值一致在被修改而地址不变(面试题)
fmt.Println(m[key])
}
}
func main() {
// var num int = 100
// reflectTest01(num) // (基本数据类型、interface{}、reflect.Value)进行反射的基本操作
// stu := Student{
// Name: "tom",
// Age: 12,
// }
// reflectTest02(stu) // (基本数据类型、interface{}、reflect.Value)进行反射的基本操作
// var a = 10
// reflectTest03(&a) // 通过反射修改值, 需要传入指针
// fmt.Println(a)
/*
reflect.Value.Elem() var num = 10; var b *int = # *b = 100
*/
// var f1 = 10.2
// // var f1 = Student{}
// reflectTest04(f1) // 练习 给你一个变量 var v float64 = 1.2 , 请使用反射来得到它的 reflect.Value, 然后获取对应Type,Kind 和值，并将 reflect.Value 转换成 interface{} , 再将 interface{} 转换成 float64.
// var m1 = Monster{
// Name: "牛魔王",
// Age: 12,
// Score: 12.2,
// Sex: "femal",
// }
// reflectTest05(m1) //通过获取方法, 字段等 m1的方法绑定时需要和Monster, 而不是*Monster, 要不然获取不出来方法
// https://studygolang.com/articles/12348?fr=sidebar 具体仔细阅读这个博客
// reflectTest06(m1) // 获取字段类型以及方法类型
test1() // 面试题
}
/*
1) reflect.Value.Kind，获取变量的类别，返回的是一个常量
2) Type 和 Kind 的区别
Type 是类型, Kind 是类别， Type 和 Kind 可能是相同的，也可能是不同的.
比如: var num int = 10 num 的 Type 是 int , Kind 也是 int
比如: var stu Student stu 的 Type 是 pkg1.Student , Kind 是 struct
3) 通过 反射可以将变量在interface{}和Reflet.Value之间转换
变量<---------> interface{} <------------> reflect.Value
4)式用反射的方式来获取变量的值(并返回对应的类型)，要求数据类型匹配，比如x是int,
那么就应该使用reflect.Value(x).Int(),而不能使用其它的，否则报panic
5) 通过反射的来修改变量, 注意当使用 SetXxx 方法来设置需要通过对应的指针类型来完成, 这样
才能改变传入的变量的值, 同时需要使用到 reflect.Value.Elem()方
*/