反射：可以在运行时动态获取变量的相关信息
go语言中通过reflect包操作反射
获取基本类型
reflect.TypeOf() //获取变量的类型，返回reflect.Type类型
reflect.ValueOf() //获取变量的值，返回reflect.Value类型
reflect.Value.Kind() //获取变量的类别，返回一个常量
reflect.Value.Interface() //转换成interface{}类型
例子:
package main
import (
"fmt"
"reflect"
)
func main() {
var a float64 = 3.14
fmt.Println("type: ", reflect.TypeOf(a))
b := reflect.ValueOf(a)
fmt.Println("value: ", b)
fmt.Println("type: ", b.Type())
fmt.Println("kind: ", b.Kind())
fmt.Println("value: ", b.Float())
fmt.Println(b.Interface())
fmt.Printf("value is %5.2e\n", b.Interface())
c := b.Interface().(float64)
fmt.Println(c)
}
输出结果：
type: float64
value: 3.14
type: float64
kind: float64
value: 3.14
3.14
value is 3.14e+00
3.14
获取结构体
例子:
package main
import (
"fmt"
"reflect"
)
type Member struct {
Name string
Age int
}
func testStruct(b interface{}) {
t := reflect.TypeOf(b)
fmt.Println("type: ", t)
v := reflect.ValueOf(b)
fmt.Println("value: ", v)
k := v.Kind()
fmt.Println("kind: ", k)
iv := v.Interface()
mem, ok := iv.(Member)
if ok {
fmt.Printf("%v %T\n", mem, mem)
}
}
func main() {
var a = Member{
Name: "Musker",
Age: 22,
}
testStruct(a)
}
输出结果:
type: main.Member
value: {Musker 22}
kind: struct
{Musker 22} main.Member
Elem反射操作基本类型
用来获取指针指向的变量，相当于： var a *int;
例子
package main
import (
"fmt"
"reflect"
)
func testEm(a interface{}) {
val := reflect.ValueOf(a)
ve := val.Elem()
ve.SetInt(100)
b := ve.Int()
fmt.Printf("get value interface{} %d\n", b)
fmt.Printf("string val: %d\n", val.Elem().Int())
}
func main() {
var a int = 1
fmt.Println("before: ", a)
testEm(&a)
fmt.Println("after: ", a)
}
输出结果:
before: 1
get value interface{} 100
string val: 100
after: 100
反射调用结构体方法
例子：
package main
import (
"fmt"
"reflect"
)
type Student struct {
Name string
Age int
Score float32
}
func (s Student) Print() {
fmt.Println(s)
}
func (s Student) Set(name string, age int, score float32) {
s.Name = name
s.Age = age
s.Score = score
}
func TestStruct(a interface{}) {
val := reflect.ValueOf(a)
kd := val.Kind()
fmt.Println(val, kd)
// 判断是否为struct
if kd != reflect.Struct {
fmt.Println("expect struct")
return
}
// 获取字段数量
fields := val.NumField()
fmt.Printf("strut has %d field\n", fields)
// 获取字段类型
for i := 0; i < fields; i++ {
fmt.Printf("%d %v\n", i, val.Field(i).Kind())
}
// 获取方法数量
methods := val.NumMethod()
fmt.Printf("struct has %d methods\n", methods)
// 反射调用Print方法
var params []reflect.Value
// params为参数列表，此处为[]
val.Method(0).Call(params)
}
func main() {
var a Student = Student{
Name: "Musker",
Age: 22,
Score: 99.99,
}
TestStruct(a)
}
输出结果：
{Musker 22 99.99} struct
strut has 3 field
0 string
1 int
2 float32
struct has 2 methods
{Musker 22 99.99}
Elem反射操作结构体
例子：
package main
import (
"fmt"
"reflect"
)
type Student struct {
Name string
Age int
Score float32
}
func (s Student) Print() {
fmt.Println(s)
}
func TestStruct(a interface{}) {
val := reflect.ValueOf(a)
kd := val.Kind()
fmt.Println(val, kd)
if kd != reflect.Ptr && val.Elem().Kind() == reflect.Struct {
fmt.Println("expect struct")
return
}
// 获取字段数量
fields := val.Elem().NumField()
fmt.Printf("struct has %d field\n", fields)
//获取字段类型
for i := 0; i < fields; i++ {
fmt.Printf("%d %v\n", i, val.Elem().Field(i).Kind())
}
// 获取方法数量
methods := val.Elem().NumField()
fmt.Printf("struct has %d methods\n", methods)
// 反射调用Print方法
var params []reflect.Value
val.Elem().Method(0).Call(params)
}
func main() {
var a Student = Student{
Name: "stu01",
Age: 18,
Score: 92.8,
}
TestStruct(&a)
}
输出结果：
&{stu01 18 92.8} ptr
struct has 3 field
0 string
1 int
2 float32
struct has 3 methods
{stu01 18 92.8}
Elem反射获取tag
例子：
package main
import (
"fmt"
"reflect"
)
type Student struct {
Name string `json:"stu_name"`
Age int
Score float32
}
func TestStruct(a interface{}) {
typ := reflect.TypeOf(a)
tag := typ.Elem().Field(0).Tag.Get("json")
fmt.Printf("tag: %s\n", tag)
}
func main() {
var a Student = Student{
Name: "Musker",
Age: 22,
Score: 99.99,
}
TestStruct(&a)
}
输出结果：
tag: stu_name
