Go语言学习笔记之反射用法详解
本文实例讲述了Go学习笔记之反射用法。分享给大家供大家参考，具体如下：
一、类型(Type)
反射（reflect）让我们能在运行期探知对象的类型信息和内存结构，这从一定程度上弥(mi)补了静态语言在动态行为上的不足。同时，反射还是实现元编程的重要手段。
和C数据结构一样，Go对象头部并没有类型指针，通过其自身是无法在运行期获知任何类型相关信息的。反射操作所需要的全部信息都源自接口变量。接口变量除存储自身类型外，还会保存实际对象的类型数据。
funcTypeOf(iinterface{})Type
funcValueOf(iinterface{})Value
这两个反射入口函数，会将任何传入的对象转换为接口类型。
在面对类型时，需要区分Type和Kind。前者表示真实类型（静态类型），后者表示其基础结构（底层类型）类别--基类型。
typeXint
funcmain(){
varaX=100
t:=reflect.TypeOf(a)
fmt.Println(t)
fmt.Println(t.Name(),t.Kind())
}
输出：
Xint
所以在类型判断上，须选择正确的方式
typeXint
typeYint
funcmain(){
vara,bX=100,200
varcY=300
ta,tb,tc:=reflect.TypeOf(a),reflect.TypeOf(b),reflect.TypeOf(c)
fmt.Println(ta==tb,ta==tc)
fmt.Println(ta.Kind()==tc.Kind())
}除通过实际对象获取类型外，也可直接构造一些基础复合类型。
funcmain(){
a:=reflect.ArrayOf(10,reflect.TypeOf(byte(0)))
m:=reflect.MapOf(reflect.TypeOf(""),reflect.TypeOf(0))
fmt.Println(a,m)
}输出：
[10]uint8map[string]int
传入对象应区分基类型和指针类型，因为它们并不属于同一类型。
funcmain(){
x:=100
tx,tp:=reflect.TypeOf(x),reflect.TypeOf(&x)
fmt.Println(tx,tp,tx==tp)
fmt.Println(tx.Kind(),tp.Kind())
fmt.Println(tx==tp.Elem())
}
输出：
int*intfalse intptr true
方法Elem()返回指针、数组、切片、字典（值）或通道的基类型。
funcmain(){
fmt.Println(reflect.TypeOf(map[string]int{}).Elem())
fmt.Println(reflect.TypeOf([]int32{}).Elem())
}输出：
int int32
只有在获取结构体指针的基类型后，才能遍历它的字段。
typeuserstruct{
namestring
ageint
}
typemanagerstruct{
user
titlestring
}
funcmain(){
varmmanager
t:=reflect.TypeOf(&m)
ift.Kind()==reflect.Ptr{
t=t.Elem()
}
fori:=0;i
输出：
usermain.user0
namestring
ageint
titlestring24
对于匿名字段，可用多级索引（按照定义顺序）直接访问。
typeuserstruct{
namestring
age int
}
typemanagerstruct{
user
titlestring
}
funcmain(){
varmmanager
t:=reflect.TypeOf(m)
name,_:=t.FieldByName("name")//按名称查找
fmt.Println(name.Name,name.Type)
age:=t.FieldByIndex([]int{0,1})//按多级索引查找
fmt.Println(age.Name,age.Type)
}
输出：
namestring
ageint
FieldByName()不支持多级名称，如有同名遮蔽，须通过匿名字段二次获取。
同样地，输出方法集时，一样区分基类型和指针类型。
typeAint
typeBstruct{
A
}
func(A)av(){}
func(*A)ap(){}
func(B)bv(){}
func(*B)bp(){}
funcmain(){
varbB
t:=reflect.TypeOf(&b)
s:=[]reflect.Type{t,t.Elem()}
for_,t2:=ranges{
fmt.Println(t2,":")
fori:=0;i
输出：
*main.B:
{apmainfunc(*main.B)0}
{avmainfunc(*main.B)1}
{bpmainfunc(*main.B)2}
{bvmainfunc(*main.B)3}
main.B:
{avmainfunc(*main.B)0}
{bvmainfunc(*main.B)1}
有一点和想象的不同，反射能探知当前包或外包的非导出结构成员。
import(
"net/http"
"reflect"
"fmt"
)
funcmain() {
varshttp.Server
t:=reflect.TypeOf(s)
fori:=0;i
输出：
Addr
Handler
ReadTimeout
WriteTimeout
TLSConfig
MaxHeaderBytes
TLSNextProto
ConnState
ErrorLog
disableKeepAlives
nextProtoOnce
nextProtoErr
相对reflect而言，当前包和外包都是“外包”。
可用反射提取structtag，还能自动分解。其常用于ORM映射，或数据格式验证。
typeuserstruct{
namestring`field:"name"type:"varchar(50)"`
age int`field:"age"type:"int"`
}
funcmain(){
varuuser
t:=reflect.TypeOf(u)
fori:=0;i
输出：
name:namevarchar(50)
age:ageint
辅助判断方法Implements()、ConvertibleTo、AssignableTo()都是运行期进行动态调用和赋值所必需的。
typeXint
func(X)String()string{
return""
}
funcmain() {
varaX
t:=reflect.TypeOf(a)
//Implements不能直接使用类型作为参数，导致这种用法非常别扭
st:=reflect.TypeOf((*fmt.Stringer)(nil)).Elem()
fmt.Println(t.Implements(st))
it:=reflect.TypeOf(0)
fmt.Println(t.ConvertibleTo(it))
fmt.Println(t.AssignableTo(st),t.AssignableTo(it))
}
输出：
true
true
truefalse
二、值(Value)
和Type获取类型信息不同，Value专注于对象实例数据读写。
在前面章节曾提到过，接口变量会复制对象，且是unaddressable的，所以要想修改目标对象，就必须使用指针。
funcmain() {
a:=100
va,vp:=reflect.ValueOf(a),reflect.ValueOf(&a).Elem()
fmt.Println(va.CanAddr(),va.CanSet())
fmt.Println(vp.CanAddr(),vp.CanSet())
}
输出：
falsefalse
truetrue
就算传入指针，一样需要通过Elem()获取目标对象。因为被接口存储的指针本身是不能寻址和进行设置操作的。
注意，不能对非导出字段直接进行设置操作，无论是当前包还是外包。
typeUserstruct{
Namestring
codeint
}
funcmain(){
p:=new(User)
v:=reflect.ValueOf(p).Elem()
name:=v.FieldByName("Name")
code:=v.FieldByName("code")
fmt.Printf("name:canaddr=%v,canset=%v\n",name.CanAddr(),name.CanSet())
fmt.Printf("code:canaddr=%v,canset=%v\n",code.CanAddr(),code.CanSet())
ifname.CanSet(){
name.SetString("Tom")
}
ifcode.CanAddr(){
*(*int)(unsafe.Pointer(code.UnsafeAddr()))=100
}
fmt.Printf("%+v\n",*p)
}
输出：
name:canaddr=true,canset=true
code:canaddr=true,canset=false
{Name:Tomcode:100}
Value.Pointer和Value.Int等方法类型，将Value.data存储的数据转换为指针，目标必须是指针类型。而UnsafeAddr返回任何CanAddrValue.data地址（相当于&取地址操作），比如Elem()后的Value，以及字段成员地址。
以结构体里的指针类型字段为例，Pointer返回该字段所保存的地址，而UnsafeAddr返回该字段自身的地址（结构对象地址+偏移量）。
可通过Interface方法进行类型推荐和转换。
funcmain(){
typeuserstruct{
Namestring
Age int
}
u:=user{
"q.yuhen",
60,
}
v:=reflect.ValueOf(&u)
if!v.CanInterface(){
println("CanInterface:fail.")
return
}
p,ok:=v.Interface().(*user)
if!ok{
println("Interface:fail.")
return
}
p.Age++
fmt.Printf("%+v\n",u)
}
输出：
{Name:q.yuhenAge:61}
也可以直接使用Value.Int、Bool等方法进行类型转换，但失败时会引发pani，且不支持ok-idiom。
复合类型对象设置示例：
funcmain() {
c:=make(chanint,4)
v:=reflect.ValueOf(c)
ifv.TrySend(reflect.ValueOf(100)){
fmt.Println(v.TryRecv())
}
}
输出：
100true
接口有两种nil状态，这一直是个潜在麻烦。解决方法是用IsNil()判断值是否为nil。
funcmain() {
varainterface{}=nil
varbinterface{}=(*int)(nil)
fmt.Println(a==nil)
fmt.Println(b==nil,reflect.ValueOf(b).IsNil())
}
输出：
true
falsetrue
也可用unsafe转换后直接判断iface.data是否为零值。
funcmain() {
varbinterface{}=(*int)(nil)
iface:=(*[2]uintptr)(unsafe.Pointer(&b))
fmt.Println(iface,iface[1]==0)
}
输出：
&[7121600]true
让人很无奈的是，Value里的某些方法并未实现ok-idom或返回error，所以得自行判断返回的是否为ZeroValue。
funcmain() {
v:=reflect.ValueOf(struct{namestring}{})
println(v.FieldByName("name").IsValid())
println(v.FieldByName("xxx").IsValid())
}
输出：
true
false
三、方法
动态调用方法，谈不上有多麻烦。只须按In列表准备好所需参数即可。
typeXstruct{}
func(X)Test(x,yint)(int,error) {
returnx+y,fmt.Errorf("err:%d",x+y)
}
funcmain() {
varaX
v:=reflect.ValueOf(&a)
m:=v.MethodByName("Test")
in:=[]reflect.Value{
reflect.ValueOf(1),
reflect.ValueOf(2),
}
out:=m.Call(in)
for_,v:=rangeout{
fmt.Println(v)
}
}
输出：
3
err:3
对于变参来说，用CallSlice()要更方便一些。
typeXstruct{}
func(X)Format(sstring,a...interface{})string{
returnfmt.Sprintf(s,a...)
}
funcmain(){
varaX
v:=reflect.ValueOf(&a)
m:=v.MethodByName("Format")
out:=m.Call([]reflect.Value{
reflect.ValueOf("%s=%d"),//所有参数都须处理
reflect.ValueOf("x"),
reflect.ValueOf(100),
})
fmt.Println(out)
out=m.CallSlice([]reflect.Value{
reflect.ValueOf("%s=%d"),
reflect.ValueOf([]interface{}{"x",100}),
})
fmt.Println(out)
}
输出：
[x=100]
[x=100]
无法调用非导出方法，甚至无法获取有效地址。
四、构建
反射库提供了内置函数make()和new()的对应操作，其中最有意思的就是MakeFunc()。可用它实现通用模板，适应不同数据类型。
//通用算法函数
funcadd(args[]reflect.Value)(results[]reflect.Value){
iflen(args)==0{
returnnil
}
varretreflect.Value
switchargs[0].Kind(){
casereflect.Int:
n:=0
for_,a:=rangeargs{
n+=int(a.Int())
}
ret=reflect.ValueOf(n)
casereflect.String:
ss:=make([]string,0,len(args))
for_,s:=rangeargs{
ss=append(ss,s.String())
}
ret=reflect.ValueOf(strings.Join(ss,""))
}
results=append(results,ret)
return
}
//将函数指针参数指向通用算法函数
funcmakeAdd(fptrinterface{}){
fn:=reflect.ValueOf(fptr).Elem()
v:=reflect.MakeFunc(fn.Type(),add)//这是关键
fn.Set(v) //指向通用算法函数
}
funcmain(){
varintAddfunc(x,yint)int
varstrAddfunc(a,bstring)string
makeAdd(&intAdd)
makeAdd(&strAdd)
println(intAdd(100,200))
println(strAdd("hello,","world!"))
}
输出：
300
hello,world!
如果语言支持泛型，自然不需要这么折腾
希望本文所述对大家Go语言程序设计有所帮助。