《Go学习笔记 . 雨痕》反射
一、类型(Type)
反射(reflect)让我们能在运行期探知对象的类型信息和内存结构,这从一定程度上弥(mi)补了静态语言在动态行为上的不足。同时,反射还是实现元编程的重要手段。
和 C 数据结构一样,Go 对象头部并没有类型指针,通过其自身是无法在运行期获知任何类型相关信息的。反射操作所需要的全部信息都源自接口变量。接口变量除存储自身类型外,还会保存实际对象的类型数据。
func TypeOf(i interface{}) Type
func ValueOf(i interface{}) Value
这 两个 反射入口函数,会将任何传入的对象转换为接口类型。
在面对类型时,需要区分 Type 和 Kind。前者表示真实类型(静态类型),后者表示其基础结构(底层类型)类别 -- 基类型。
type X int func main() {
var a X = 100
t := reflect.TypeOf(a) fmt.Println(t)
fmt.Println(t.Name(), t.Kind())
}
输出:
X int
所以在类型判断上,须选择正确的方式
type X int
type Y int func main() {
var a, b X = 100, 200
var c Y = 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())
}
除通过实际对象获取类型外,也可直接构造一些基础复合类型。
func main() {
a := reflect.ArrayOf(10, reflect.TypeOf(byte(0)))
m := reflect.MapOf(reflect.TypeOf(""), reflect.TypeOf(0)) fmt.Println(a, m)
}
输出:
[10]uint8 map[string]int
传入对象 应区分 基类型 和 指针类型,因为它们并不属于同一类型。
func main() {
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 *int false
int ptr
true
方法 Elem() 返回 指针、数组、切片、字典(值)或 通道的 基类型。
func main() {
fmt.Println(reflect.TypeOf(map[string]int{}).Elem())
fmt.Println(reflect.TypeOf([]int32{}).Elem())
}
输出:
int
int32
只有在获取 结构体指针 的 基类型 后,才能遍历它的字段。
type user struct {
name string
age int
} type manager struct {
user
title string
} func main() {
var m manager
t := reflect.TypeOf(&m) if t.Kind() == reflect.Ptr {
t = t.Elem()
} for i := 0; i < t.NumField(); i++ {
f := t.Field(i)
fmt.Println(f.Name, f.Type, f.Offset)
if f.Anonymous { // 输出匿名字段结构
for x := 0; x < f.Type.NumField(); x++ {
af := f.Type.Field(x)
fmt.Println(" ", af.Name, af.Type)
}
}
}
}
输出:
user main.user 0
name string
age int
title string 24
对于匿名字段,可用多级索引(按照定义顺序)直接访问。
type user struct {
name string
age int
} type manager struct {
user
title string
} func main() {
var m manager 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)
}
输出:
name string
age int
FieldByName() 不支持多级名称,如有同名遮蔽,须通过匿名字段二次获取。
同样地,输出方法集时,一样区分 基类型 和 指针类型。
type A int type B struct {
A
} func (A) av() {}
func (*A) ap() {} func (B) bv() {}
func (*B) bp() {} func main() {
var b B t := reflect.TypeOf(&b)
s := []reflect.Type{t, t.Elem()} for _, t2 := range s {
fmt.Println(t2, ":") for i := 0; i < t2.NumMethod(); i++ {
fmt.Println(" ", t2.Method(i))
}
}
}
输出:
*main.B :
{ap main func(*main.B) <func(*main.B) Value> 0}
{av main func(*main.B) <func(*main.B) Value> 1}
{bp main func(*main.B) <func(*main.B) Value> 2}
{bv main func(*main.B) <func(*main.B) Value> 3} main.B :
{av main func(*main.B) <func(*main.B) Value> 0}
{bv main func(*main.B) <func(*main.B) Value> 1}
有一点和想象的不同,反射能探知当前包或外包的非导出结构成员。
import (
"net/http"
"reflect"
"fmt"
) func main() {
var s http.Server
t := reflect.TypeOf(s) for i := 0; i < t.NumField(); i++ {
fmt.Println(t.Field(i).Name)
}
}
输出:
Addr
Handler
ReadTimeout
WriteTimeout
TLSConfig
MaxHeaderBytes
TLSNextProto
ConnState
ErrorLog
disableKeepAlives
nextProtoOnce
nextProtoErr
相对 reflect 而言,当前包 和 外包 都是“外包”。
可用反射提取 struct tag,还能自动分解。其常用于 ORM 映射,或数据格式验证。
type user struct {
name string `field:"name" type:"varchar(50)"`
age int `field:"age" type:"int"`
} func main() {
var u user
t := reflect.TypeOf(u) for i := 0; i < t.NumField(); i++ {
f := t.Field(i)
fmt.Printf("%s: %s %s\n", f.Name, f.Tag.Get("field"), f.Tag.Get("type"))
}
}
输出:
name: name varchar(50)
age: age int
辅助判断方法 Implements()、ConvertibleTo、AssignableTo() 都是运行期进行 动态调用 和 赋值 所必需的。
type X int func (X) String() string {
return ""
} func main() {
var a X
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
true false
二、值(Value)
和 Type 获取类型信息不同,Value 专注于对象实例数据读写。
在前面章节曾提到过,接口变量会复制对象,且是 unaddressable 的,所以要想修改目标对象,就必须使用指针。
func main() {
a := 100
va, vp := reflect.ValueOf(a), reflect.ValueOf(&a).Elem() fmt.Println(va.CanAddr(), va.CanSet())
fmt.Println(vp.CanAddr(), vp.CanSet())
}
输出:
false false
true true
就算传入指针,一样需要通过 Elem() 获取目标对象。因为被接口存储的指针本身是不能寻址和进行设置操作的。
注意,不能对非导出字段直接进行设置操作,无论是当前包还是外包。
type User struct {
Name string
code int
} func main() {
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()) if name.CanSet() {
name.SetString("Tom")
} if code.CanAddr() {
*(*int)(unsafe.Pointer(code.UnsafeAddr())) = 100
} fmt.Printf("%+v\n", *p)
}
输出:
name: canaddr = true, canset = true
code: canaddr = true, canset = false
{Name:Tom code:100}
Value.Pointer 和 Value.Int 等方法类型,将 Value.data 存储的数据转换为指针,目标必须是指针类型。而 UnsafeAddr 返回任何 CanAddr Value.data 地址(相当于 & 取地址操作),比如 Elem() 后的 Value,以及字段成员地址。
以结构体里的指针类型字段为例,Pointer 返回该字段所保存的地址,而 UnsafeAddr 返回该字段自身的地址(结构对象地址 + 偏移量)。
可通过 Interface 方法进行类型 推荐 和 转换。
func main() {
type user struct {
Name string
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.yuhen Age:61}
也可以直接使用 Value.Int、Bool 等方法进行类型转换,但失败时会引发 pani,且不支持 ok-idiom。
复合类型对象设置示例:
func main() {
c := make(chan int, 4)
v := reflect.ValueOf(c) if v.TrySend(reflect.ValueOf(100)) {
fmt.Println(v.TryRecv())
}
}
输出:
100 true
接口有两种 nil 状态,这一直是个潜在麻烦。解决方法是用 IsNil() 判断值是否为 nil。
func main() {
var a interface{} = nil
var b interface{} = (*int)(nil) fmt.Println(a == nil)
fmt.Println(b == nil, reflect.ValueOf(b).IsNil())
}
输出:
true
false true
也可用 unsafe 转换后直接判断 iface.data 是否为零值。
func main() {
var b interface{} = (*int)(nil)
iface := (*[2]uintptr)(unsafe.Pointer(&b)) fmt.Println(iface, iface[1] == 0)
}
输出:
&[712160 0] true
让人很无奈的是,Value 里的某些方法并未实现 ok-idom 或返回 error,所以得自行判断返回的是否为 Zero Value。
func main() {
v := reflect.ValueOf(struct {name string}{}) println(v.FieldByName("name").IsValid())
println(v.FieldByName("xxx").IsValid())
}
输出:
true
false
三、方法
动态调用方法,谈不上有多麻烦。只须按 In 列表准备好所需参数即可。
type X struct {} func (X) Test(x, y int) (int, error) {
return x + y, fmt.Errorf("err: %d", x + y)
} func main() {
var a X
v := reflect.ValueOf(&a)
m := v.MethodByName("Test") in := []reflect.Value{
reflect.ValueOf(1),
reflect.ValueOf(2),
} out := m.Call(in)
for _, v := range out {
fmt.Println(v)
}
}
输出:
3
err: 3
对于变参来说,用 CallSlice() 要更方便一些。
type X struct {} func (X) Format(s string, a ...interface{}) string {
return fmt.Sprintf(s, a...)
} func main() {
var a X
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()。可用它实现通用模板,适应不同数据类型。
// 通用算法函数
func add(args []reflect.Value) (results []reflect.Value) {
if len(args) == 0 {
return nil
} var ret reflect.Value switch args[0].Kind() {
case reflect.Int:
n := 0
for _, a := range args {
n += int(a.Int())
} ret = reflect.ValueOf(n)
case reflect.String:
ss := make([]string, 0, len(args))
for _, s := range args {
ss = append(ss, s.String())
} ret = reflect.ValueOf(strings.Join(ss, ""))
} results = append(results, ret)
return
} // 将函数指针参数指向通用算法函数
func makeAdd(fptr interface{}) {
fn := reflect.ValueOf(fptr).Elem()
v := reflect.MakeFunc(fn.Type(), add) // 这是关键
fn.Set(v) // 指向通用算法函数
} func main() {
var intAdd func(x, y int) int
var strAdd func(a, b string) string makeAdd(&intAdd)
makeAdd(&strAdd) println(intAdd(100, 200))
println(strAdd("hello, ", "world!"))
}
输出:
300
hello, world!
如果语言支持泛型,自然不需要这么折腾
《Go学习笔记 . 雨痕》反射的更多相关文章
- 《Go学习笔记 . 雨痕》方法
一.定义 方法 是与对象实例绑定的特殊函数. 方法 是面向对象编程的基本概念,用于维护和展示对象的自身状态.对象是内敛的,每个实例都有各自不同的独立特征,以 属性 和 方法 来暴露对外通信接口.普通函 ...
- 《Go学习笔记 . 雨痕》流程控制(if、switch、for range、goto、continue、break)
Go 精简(合并)了流控制语句,虽然某些时候不够便捷,但够用. if...else... 条件表达式值必须是布尔类型,可省略括号,且左花括号不能另起一行. func main() { x := 3 i ...
- 《Go学习笔记 . 雨痕》类型
一.基本类型 清晰完备的预定义基础类型,使得开发跨平台应用时无须过多考虑符合和长度差异. 类型 长度 默认值 说明 bool 1 false byte 1 0 uint8 int, uint 4, ...
- Laravel学习笔记之PHP反射(Reflection) (上)
Laravel学习笔记之PHP反射(Reflection) (上) laravel php reflect 2.1k 次阅读 · 读完需要 80 分钟 3 说明:Laravel中经常使用PHP的反 ...
- JDBC学习笔记(5)——利用反射及JDBC元数据编写通用的查询方法
JDBC元数据 1)DatabaseMetaData /** * 了解即可:DatabaseMetaData是描述数据库的元数据对象 * 可以由Connection得到 */ 具体的应用代码: @Te ...
- Java学习笔记之使用反射+泛型构建通用DAO
PS:最近简单的学了学后台Servlet+JSP.也就只能学到这里了.没那么多精力去学SSH了,毕竟Android还有很多东西都没学完.. 学习内容: 1.如何使用反射+泛型构建通用DAO. 1.使用 ...
- Java学习笔记54(反射详解)
反射概念: java反射机制是在运行状态中,对于任意一个类,都能知道所有属性和方法 对于任意一个对象都能调用它的任意一个方法和属性,这种动态获取和调用的功能称为java的反射机制 实际作用: 已经完成 ...
- Quartz.net 2.x 学习笔记03-使用反射加载定时任务
将定时任务信息存储在XML文件中,使用反射加载定时任务 首先新建一个MVC的空站点,使用NuGet添加对Quartz.net和Common.Logging.Log4Net1213的引用,同时使用NuG ...
- Android(java)学习笔记106-2:反射机制
1.反射机制: JAVA反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法:对于任意一个对象,都能够调用它的任意一个方法和属性:这种动态获取的信息以及动态调用对象的方法的功能称为 ...
随机推荐
- 关于golang的defer的练习
golang的defer怎么说.大意就是在函数return后.函数关闭前.按照filo的顺序来执行的关键字 上代码: package main import ( "fmt" ) f ...
- networkManger介绍
http://www.linuxidc.com/Linux/2013-08/88809.htm
- EM算法原理详解
1.引言 以前我们讨论的概率模型都是只含观测变量(observable variable), 即这些变量都是可以观测出来的,那么给定数据,可以直接使用极大似然估计的方法或者贝叶斯估计的方法:但是当模型 ...
- 【技术知识】恶意PDF文件分析-PDFdump的问题
1.提醒 百度分析恶意PDF文件,很多都是推荐PDFdump.在某次沙箱产品分析出疑似高级威胁的PDF样本后,我使用PDFdump查看ShellCode的加密数据,分析后并没有找到相关的ShellCo ...
- Linux下USB suspend/resume源码分析【转】
转自:http://blog.csdn.net/aaronychen/article/details/3928479 Linux下USB suspend/resume源码分析 Author:aaron ...
- oracle中使用sql语句生成10w条测试数据
sql语句 create table AAAATest as select rownum as cardNo, 'test' creator, to_char(sysdate + rownum//, ...
- Eclipse 中 不能创建 Dynamic web project
工作要涉及web开发,之前下载的java SE (我的是luna) 版本默认无法新建web项目,也就是找不到Dynamic Web ,在网上看了些解决办法,最终却是解决了问题,说到底就是安装一些用于E ...
- maven dependencies 报错
maven配置的环境变量有问题: 用最新的maven替换系统默认的setting.xml文件即可
- MySQL缓存命中率概述
工作原理: 查询缓存的工作原理,基本上可以概括为: 缓存SELECT操作或预处理查询(注释:5.1.17开始支持)的结果集和SQL语句: 新的SELECT语句或预处理查询语句,先去查询缓存,判断是否存 ...
- 记一些使用PyQt的问题
本文自用,日常记录,不断更新 环境 1.使用 PyCharm IDE 2.PyQt5 3. 扩展配置 PyUIC转换后的代码处理 PyUIC 用于 将 QtDesigner 生成的 .ui 文件转换为 ...