go--反射&常量
适配器函数
bridge := func(call interface{},args ...interface{}){
//内容
}
反射基本介绍
package reflect
//官网relect的Type
type Type interface {
// Kind返回该接口的具体分类
Kind() Kind
// Name返回该类型在自身包内的类型名，如果是未命名类型会返回""
Name() string
// PkgPath返回类型的包路径，即明确指定包的import路径，如"encoding/base64"
// 如果类型为内建类型(string, error)或未命名类型(*T, struct{}, []int)，会返回""
PkgPath() string
// 返回类型的字符串表示。该字符串可能会使用短包名（如用base64代替"encoding/base64"）
// 也不保证每个类型的字符串表示不同。如果要比较两个类型是否相等，请直接用Type类型比较。
String() string
// 返回要保存一个该类型的值需要多少字节；类似unsafe.Sizeof
Size() uintptr
// 返回当从内存中申请一个该类型值时，会对齐的字节数
Align() int
// 返回当该类型作为结构体的字段时，会对齐的字节数
FieldAlign() int
// 如果该类型实现了u代表的接口，会返回真
Implements(u Type) bool
// 如果该类型的值可以直接赋值给u代表的类型，返回真
AssignableTo(u Type) bool
// 如该类型的值可以转换为u代表的类型，返回真
ConvertibleTo(u Type) bool
// 返回该类型的字位数。如果该类型的Kind不是Int、Uint、Float或Complex，会panic
Bits() int
// 返回array类型的长度，如非数组类型将panic
Len() int
// 返回该类型的元素类型，如果该类型的Kind不是Array、Chan、Map、Ptr或Slice，会panic
Elem() Type
// 返回map类型的键的类型。如非映射类型将panic
Key() Type
// 返回一个channel类型的方向，如非通道类型将会panic
ChanDir() ChanDir
// 返回struct类型的字段数（匿名字段算作一个字段），如非结构体类型将panic
NumField() int
// 返回struct类型的第i个字段的类型，如非结构体或者i不在[0, NumField())内将会panic
Field(i int) StructField
// 返回索引序列指定的嵌套字段的类型，
// 等价于用索引中每个值链式调用本方法，如非结构体将会panic
FieldByIndex(index []int) StructField
// 返回该类型名为name的字段（会查找匿名字段及其子字段），
// 布尔值说明是否找到，如非结构体将panic
FieldByName(name string) (StructField, bool)
// 返回该类型第一个字段名满足函数match的字段，布尔值说明是否找到，如非结构体将会panic
FieldByNameFunc(match func(string) bool) (StructField, bool)
// 如果函数类型的最后一个输入参数是"..."形式的参数，IsVariadic返回真
// 如果这样，t.In(t.NumIn() - 1)返回参数的隐式的实际类型（声明类型的切片）
// 如非函数类型将panic
IsVariadic() bool
// 返回func类型的参数个数，如果不是函数，将会panic
NumIn() int
// 返回func类型的第i个参数的类型，如非函数或者i不在[0, NumIn())内将会panic
In(i int) Type
// 返回func类型的返回值个数，如果不是函数，将会panic
NumOut() int
// 返回func类型的第i个返回值的类型，如非函数或者i不在[0, NumOut())内将会panic
Out(i int) Type
// 返回该类型的方法集中方法的数目
// 匿名字段的方法会被计算；主体类型的方法会屏蔽匿名字段的同名方法；
// 匿名字段导致的歧义方法会滤除
NumMethod() int
// 返回该类型方法集中的第i个方法，i不在[0, NumMethod())范围内时，将导致panic
// 对非接口类型T或*T，返回值的Type字段和Func字段描述方法的未绑定函数状态
// 对接口类型，返回值的Type字段描述方法的签名，Func字段为nil
Method(int) Method
// 根据方法名返回该类型方法集中的方法，使用一个布尔值说明是否发现该方法
// 对非接口类型T或*T，返回值的Type字段和Func字段描述方法的未绑定函数状态
// 对接口类型，返回值的Type字段描述方法的签名，Func字段为nil
MethodByName(string) (Method, bool)
// 内含隐藏或非导出方法
}
通过反射我们可以拿到
reflect.Type类型(reflect.TypeOf(v))
//官网relect的Value
type Value struct {
// 内含隐藏或非导出字段
}
通过反射我们可以拿到
reflect.Value类型(reflect.ValueOf(v))
反射的相关函数和转换
//专门用于做反射
func test(b interface{}){
//1.如何将interface{}转成reflect.value
rVal := reflect.ValueOf(b)
//2.将reflect.value转成interface{}
iVal := rVal.Interface()
//3. 如何将interface转成原来的变量类型(使用类型断言)
v := iVal.(Stu)
}
反射的快速入门
对(基本数据类型,interface{},reflect.Value)进行反射的基本操作
package main
import (
"fmt"
"reflect"
)
func ReflectTest01(b interface{}){
//通过反射获取传入的type(类型),kind(类别),值
//先获取到reflect.Type
rTyp := reflect.TypeOf(b)
fmt.Println("rType=",rTyp)//返回显示虽然是int，实际上是reflect.Type类型
//2.获取到reflect.Value
rVal := reflect.ValueOf(b)
fmt.Printf("rValue=%v,type=%T\n",rVal,rVal)//返回显示虽然是100，实际上是reflect.Value类型
fmt.Printf("真正的值=%v,type=%T\n",rVal.Int(),rVal.Int())
//将rVal转成interface{}
iV := rVal.Interface()
//将interface{}经过断言转成需要的类型
num := iV.(int)
fmt.Println("num=",num)
}
func main(){
//1.先定义一个int
var num int = 100
ReflectTest01(num)
}
对(结构体,interface{},reflect.Value)进行反射的基本操作
package main
import (
"fmt"
"reflect"
)
type Stu struct{
Name string
Age int
}
func ReflectTest02(b interface{}){
//通过反射获取传入的type(类型),kind(类别),值
//先获取到reflect.Type
rTyp := reflect.TypeOf(b)
fmt.Println("rType=",rTyp)//实际上是reflect.Type类型
//2.获取到reflect.Value
rVal := reflect.ValueOf(b)
fmt.Printf("rValue=%v,type=%T\n",rVal,rVal)//实际上是reflect.Value类型
//将rVal转成interface{}
iV := rVal.Interface()
//将interface{}经过断言转成需要的类型
fmt.Printf("iV=%v,type=%T\n",iV,iV)//iV={admin 20},type=main.Stu
}
func main(){
//1.先定义一个Stu实例对象
stu := Stu{
Name: "admin",
Age: 20,
}
ReflectTest02(stu)
}
获取kind(类别)
//先获取到reflect.Type
rTyp := reflect.TypeOf(b)
fmt.Println("rType=",rTyp)//实际上是reflect.Type类型
//2.获取到reflect.Value
rVal := reflect.ValueOf(b)
fmt.Printf("rValue=%v,type=%T\n",rVal,rVal)//实际上是reflect.Value类型
//3.获取变量对应的kind()
kind1 := rTyp.Kind()
kind2 := rVal.Kind()
fmt.Printf("rType kind=%v,rVal kind=%v\n",kind1,kind2)
常量
- 常量使用
const - 常量在定义的时候，必须初始化
- 常量不能修改
- 常量只能修饰
bool、数值类型(int,float系列)、string类型 - 语法:
const 常量名 [type] = value
const (
a = iota //表示给a赋值一个0
b
c
)
反射注意事项和细节
- reflect.Value.Kind,获取变量的类别，返回的是一个常量(看手册)
- Type是类型，Kind是类别，Type和Kind可能是相同的，也可以是不同的
- 比如:
var num int = 10num的Type是int,Kind也是int - 比如:
var stu Stustu的Type是包名.Stu,Kind是struct
- 通过反射可以让变量在interface{}和reflect.Value之间相互转换
变量<---------->interface{}<------------->reflect.Value
-
使用反射的方式获取变量的值(并返回对应的类型)要求数据类型匹配，比如
x是int，那么就应该reflect.ValueOf(x).Int(),而不能使用其他的，否则回报panic;结构体要类型断言 -
通过反射的来修改变量，注意当使用
SetXxx方法来设置需要通过的对应的指针类型来完成，这样才能修改传入的变量的值，同时需要使用到reflect.Va;ueOf().Elem()方法
问题
//通过反射修改num int的值&修改student的值
func reflect01(b interface{}){
rVal := reflect.ValueOf(b)
rVal.SetSInt(20)
}
func main(){
var num int = 10
reflect01(&num)//num:这样传入num值不会改变，所以传入num地址
}
其实
reflect.ValueOf()返回的类型是一个指针
问题解决
reflect.ValueOf(interface{}).Elem().SetInt(value)
//通过反射修改num int的值&修改student的值
func reflect01(b interface{}){
rVal := reflect.ValueOf(b)
rVal.Elem().SetInt(20)
}
func main(){
var num int = 10
reflect01(&num)//num:这样传入num值不会改变，所以传入num地址
fmt.Println("num = ",num)
}
- 怎么理解
reflect.ValueOf(interface{}).Elem().SetInt(value)
/*
func main(){
var num = 10
var b *int = &num
*b = 3
}
*/
func main(){
var num int = 100
fn := reflect.ValueOf(&num)
fn.Elem().SetInt(200)
}
反射最佳实践
- 使用反射来遍历结构体的字段，调用结构体的方法，并获取结构体标签的值
获取reflect.Type类型
reflect.TypeOf(interface{})
获取reflect.Value类型
reflect.ValueOf(interface{})
获取到对应的类别
reflect.ValueOf(interface{}).Kind()
获取结构体有几个字段
reflect.ValueOf(interface{}).NumField()
获取结构体字段
reflect.ValueOf(interface{}).Field()
获取struct标签，需要通过reflect.Type来获取tag标签的值
reflect.TypeOf(interface{}).Field(number).Tag.Get("json")
获取结构体有多少个方法
reflect.ValueOf(interface{}).NumMethod()
调用方法
//reflect.ValueOf(interface{}).Method(num): 获取到结构体的第几个方法,初始值是0开始(0是第一个,1是第二个...)
//Call(nil):传输的值是空
//方法的排序默认是按照函数名排序(ASCII码的大小排序)
reflect.ValueOf(interface{}).Method(num).Call(nil)
反射方法原则
在进行方法排序的时候，是按照函数的名字进行排序（先比较ascii码）
Print()//2
GetSum()//1
Set()//3
反射操作结构体类型
type User struct{
Uid string
Name string
}
func TestReflectStruct(t *testing.T){
var (
model *User
st reflect.Type
elem reflect.Value
)
st = reflect.TypeOf(model)//获取类型*User
t.Log(st.Kind().String()) //ptr
st = st.Elem()//指向的类型
t.Log(st.Kind().String()) //struct
elem = reflect.New(st) //New返回一个Value类型的值，类似于java底层的new
model = elem.Interface().(*User)//转成interface{}类型后通过类型断言重新变成*User
elem = elem.Elem()//取得elem指向的值
elem.FeildByName("Uid").SetString("value")//赋值
elem.FeildByName("Name").SetString("value")
}