变量 ---> 一个值，一个类型，值类型
数组 ---> 相同类型，多个值，长度固定，值类型
切片 ---> 相同类型，多个值，长度动态，引用类型，有序
指针 ---> 地址，引用类型
映射 ---> k-v 按名字取值，无序，相同类型，多个值，长度动态
结构体 ---> 多个值，类型多样，字段（属性）
接口 ---> 接受任意类型的定义
反射概念：运行时动态的获取变量的相关信息。
import ("reflect")
1. reflect
1、 reflect.TypeOf获取变量类型，返回reflect.Type类型；
2、 reflect.ValueOf获取变量的值，返回reflect.Value类型；
3、 reflect.Value.Kind获取变量的类别，返回一个常量；
4、 reflect.Value.Interface()转换成**interface{}**类型；
int ---> interface ---> reflect.value ---> string
示例：获取变量类型
package main
import (
"fmt"
"reflect"
)
func test(i interface{
}) {
// 反射获取值类型
t := reflect.TypeOf(i)
fmt.Println(t)
// 反射获取值
v := reflect.ValueOf(i)
fmt.Println(v)
}
func main() {
var a int = 10
test(a)
}
/*
int
10
*/
示例：类型和类别
package main
import (
"fmt"
"reflect"
)
type Student struct {
Name string
Age int
Score float32
}
func test(i interface{
}) {
// 反射获取类型
t := reflect.TypeOf(i)
fmt.Println("类型：",t)
// 反射获取类别
v := reflect.ValueOf(i)
k := v.Kind()
fmt.Println("类别：",k)
}
func main() {
var stu Student = Student {
Name: "zhangsan",
Age: 19,
Score: 88,
}
test(stu)
}
/*
类型： main.Student
类别： struct
*/
示例：断言处理类型转化
package main
import (
"fmt"
"reflect"
)
type Student struct {
Name string
Age int
Score float32
}
func test(i interface{
}) {
// 反射获取类型
t := reflect.TypeOf(i)
fmt.Println("类型：",t)
// 反射获取类别
v := reflect.ValueOf(i)
k := v.Kind()
fmt.Println("类别：",k)
// 转换成接口类型
iv := v.Interface()
// 断言
stu,ok := iv.(Student)
if ok {
fmt.Printf("结构：%v 类型：%T\n",stu,stu)
}
}
func main() {
var stu Student = Student {
Name: "zhangsan",
Age: 19,
Score: 88,
}
test(stu)
}
/*
类型： main.Student
类别： struct
结构：{zhangsan 19 88} 类型：main.Student
*/
2. ValueOf
获取变量值
reflect.ValueOf(x).Float()
reflect.ValueOf(x).Int()
reflect.ValueOf(x).String()
reflect.ValueOf(x).Bool()
示例:类型转换
package main
import (
"fmt"
"reflect"
)
func testInt(b interface{
}) {
val := reflect.ValueOf(b)
fmt.Printf("val 类型：%T\n",val)
// 转换成 int 类型，其他类型都可以转化成 string
a := val.Int()
fmt.Printf("a 类型：%T\n",a)
}
func main() {
testInt(100)
}
/*
val 类型：reflect.Value
a 类型：int64
*/
3. Value.Set
设置变量值
reflect.Value.SetFloat() #设置浮点数
reflect.Value.SetInt() #设置整数
reflect.Value.SetString() #设置字符串
示例：思考为何会报错
package main
import (
"fmt"
"reflect"
)
func testInt(b interface{
}) {
val := reflect.ValueOf(b)
// 更改值
val.SetInt(100)
c := val.Int()
fmt.Printf("类型：%T,值：%d\n",c,c)
}
func main() {
var i = 10
testInt(i)
fmt.Println(i)
}
/*
panic: reflect: reflect.Value.SetInt using unaddressable value
goroutine 1 [running]:
......
*/
修改后
package main
import (
"fmt"
"reflect"
)
func testInt(b interface{
}) {
val := reflect.ValueOf(b)
// 更改值需要value的地址，否则会崩溃，Elem() 表示 *
val.Elem().SetInt(100)
c := val.Elem().Int()
fmt.Printf("类型：%T,值：%d\n",c,c)
}
func main() {
var i = 10
testInt(&i)
fmt.Println(i)
}
/*
类型：int64,值：100
100
*/
4. 结构体反射
示例：反射出结构体属性和方法数量
package main
import (
"fmt"
"reflect"
)
type Student struct {
Name string
Age int
Score float32
}
func (s Student) Sleep() {
fmt.Println("正在睡觉")
}
func (s Student) Run(min interface{
}) {
fmt.Printf("跑步%d分钟",min)
}
// 断言结构体
func Test(object interface{
}) {
// 获取值
v := reflect.ValueOf(object)
// 获取类别
c := v.Kind()
// 判断类别是否为结构体
if c != reflect.Struct {
fmt.Println("expect struct")
return
}
// 获取结构体字段数量
num := v.NumField()
fmt.Println("字段数量:",num)
// 获取结构体方法数量
numOfMethod := v.NumMethod()
fmt.Println("方法数量:",numOfMethod)
}
func main() {
var stu Student = Student {
Name: "zhangsan",
Age: 18,
Score: 90,
}
Test(stu)
}
/*
字段数量: 3
方法数量: 2
*/
5. 函数反射
示例：Go 中函数可以赋值给变量。
package main
import "fmt"
func Hello() {
fmt.Println("hello world")
}
func main() {
// 函数可以赋值给变量
a := Hello
a()
}
/*
hello world
*/
示例：既然函数可以像普通的类型变量一样，那么在反射机制中就和不同的变量是一样，在反射中函数和方法的类型 (Type) 都是 reflect.Func，如果要调用函数，通过 Value 的 Call() 方法
package main
import (
"fmt"
"reflect"
)
func Hello() {
fmt.Println("hello world")
}
func main() {
// 反射获取 hello
v := reflect.ValueOf(Hello)
fmt.Printf("类型:%T\n",v)
// 判断 hello 的类型
if v.Kind() == reflect.Func {
fmt.Println("OK")
}
// 反射调用函数
v.Call(nil)
}
/*
类型:reflect.Value
OK
hello world
*/
Value 的 Call() 方法的参数是一个 Value 的 slice，对应的反射函数类型的参数，返回值也是一个 Value 的 slice，同样对应反射函数类型的返回值。
package main
import (
"fmt"
"reflect"
"strconv"
)
func prints(i int) string {
fmt.Println("i=",i)
return strconv.Itoa(i)
}
func main() {
fv := reflect.ValueOf(prints)
// 定义参数切片
params := make([]reflect.Value,1)
// 参数为 20
params[0] = reflect.ValueOf(20)
// 反射函数，获取处理结果
result := fv.Call(params)
fmt.Printf("result 类型:%T\n",result)
fmt.Printf("result 转换后类型:%T,值是:%s\n",result[0].Interface().(string),result[0].Interface().(string))
}
/*
i= 20
result 类型:[]reflect.Value
result 转换后类型:string,值是:20
*/
6. 方法反射
反射中方法的调用。函数和方法可以说其实本质上是相同的，只不过方法与一个对象进行了绑定，方法是对象的一种行为，这种行为是对于这个对象的一系列操作，例如修改对象的某个属性。
package main
import (
"fmt"
"reflect"
"strconv"
)
type Student struct {
age int
name string
}
func (s *Student) SetAge(i int) {
s.age = i
}
func (s *Student) SetName(name string) {
s.name = name
}
func (s *Student) String() string {
return fmt.Sprintf("%p",s) + "--name:" + s.name + " age:" + strconv.Itoa(s.age)
}
func main() {
// 实例化
stu := &Student{
22,"zhangsan"}
// 反射获取值，指针方式
stuV := reflect.ValueOf(&stu).Elem()
// 也可以使用非指针（值类型） stuV := reflect.ValueOf(stu)
fmt.Println("Before:",stuV.MethodByName("String").Call(nil)[0])
// 修改值
params := make([]reflect.Value,1)
params[0] = reflect.ValueOf(18)
stuV.MethodByName("SetAge").Call(params)
params[0] = reflect.ValueOf("lisi")
stuV.MethodByName("SetName").Call(params)
fmt.Println("After:",stuV.MethodByName("String").Call(nil)[0])
}
/*
Before: 0xc000004078--name:zhangsan age:22
After: 0xc000004078--name:lisi age:18
*/
示例：使用 Method 方式
package main
import (
"fmt"
"reflect"
"strconv"
)
type Student struct {
age int
name string
}
func (s *Student) SetAge(i int) {
s.age = i
}
func (s *Student) SetName(name string) {
s.name = name
}
func (s *Student) String() string {
return fmt.Sprintf("%p",s) + "--name:" + s.name + " age:" + strconv.Itoa(s.age)
}
func main() {
// 实例化
stu := &Student{
22,"zhangsan"}
stuV := reflect.ValueOf(&stu).Elem()
// 方式二
fmt.Println("Before:",stuV.Method(2).Call(nil)[0])
// 索引大小取决于方法名称的 ASCII 大小
params := make([]reflect.Value,1)
params[0] = reflect.ValueOf(18)
stuV.Method(0).Call(params)
params[0] = reflect.ValueOf("lisi")
stuV.Method(1).Call(params)
fmt.Println("After:",stuV.Method(2).Call(nil)[0])
}
/*
Before: 0xc000004078--name:zhangsan age:22
After: 0xc000004078--name:lisi age:18
*/