《Go学习笔记 . 雨痕》反射
一、类型(Type)
反射(reflect)让我们能在运行期探知对象的类型信息和内存结构,这从一定程度上弥(mi)补了静态语言在动态行为上的不足。同时,反射还是实现元编程的重要手段。
和 C 数据结构一样,Go 对象头部并没有类型指针,通过其自身是无法在运行期获知任何类型相关信息的。反射操作所需要的全部信息都源自接口变量。接口变量除存储自身类型外,还会保存实际对象的类型数据。
func TypeOf(i interface{}) Type func ValueOf(i interface{}) Value
这 两个 反射入口函数,会将任何传入的对象转换为接口类型。
在面对类型时,需要区分 Type 和 Kind。前者表示真实类型(静态类型),后者表示其基础结构(底层类型)类别 -- 基类型。
type X intfunc main() {var a X = 100t := reflect.TypeOf(a)fmt.Println(t)fmt.Println(t.Name(), t.Kind()) }
输出:
X int
所以在类型判断上,须选择正确的方式
type X int type Y intfunc main() {var a, b X = 100, 200var c Y = 300ta, 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 := 100tx, 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 stringage int }type manager struct {usertitle string }func main() {var m managert := 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 0name stringage int title string 24
对于匿名字段,可用多级索引(按照定义顺序)直接访问。
type user struct {name stringage int }type manager struct {usertitle string }func main() {var m managert := 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 inttype B struct {A }func (A) av() {} func (*A) ap() {}func (B) bv() {} func (*B) bp() {}func main() {var b Bt := 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.Servert := 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 usert := 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 intfunc (X) String() string {return "" }func main() {var a Xt := 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 := 100va, 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 stringcode 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 stringAge 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{} = nilvar 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 Xv := 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 Xv := 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.Valueswitch args[0].Kind() {case reflect.Int:n := 0for _, 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) intvar strAdd func(a, b string) stringmakeAdd(&intAdd)makeAdd(&strAdd)println(intAdd(100, 200))println(strAdd("hello, ", "world!")) }
输出:
300 hello, world!
如果语言支持泛型,自然不需要这么折腾
转载于:https://www.cnblogs.com/52php/p/6340487.html
《Go学习笔记 . 雨痕》反射相关推荐
- 《Go学习笔记 . 雨痕》方法
一.定义 方法 是与对象实例绑定的特殊函数. 方法 是面向对象编程的基本概念,用于维护和展示对象的自身状态.对象是内敛的,每个实例都有各自不同的独立特征,以 属性 和 方法 来暴露对外通信接口.普通函 ...
- python3学习笔记 雨痕_Python 3 学习笔记:数字和布尔
数字 基本类型 整数 在 Python 编程中,整数就是数学意义上的整数,包括正整数.负整数和零,且它的位数是任意的.根据表示方法的不同,可以分为: 二进制整数 八进制整数 十进制整数 十六进制整数 ...
- 《Go学习笔记 . 雨痕》流程控制(if、switch、for range、goto、continue、break)
Go 精简(合并)了流控制语句,虽然某些时候不够便捷,但够用. if...else... 条件表达式值必须是布尔类型,可省略括号,且左花括号不能另起一行. func main() {x := 3if ...
- 《Go学习笔记 . 雨痕》类型
一.基本类型 清晰完备的预定义基础类型,使得开发跨平台应用时无须过多考虑符合和长度差异. 类型 长度 默认值 说明 bool 1 false byte 1 0 uint8 int, uint 4, ...
- Mcad学习笔记之通过反射调用類的方法,屬性,字段,索引器(2種方法)
相关文章导航 Sql Server2005 Transact-SQL 新兵器学习总结之-总结 Flex,Fms3相关文章索引 FlexAir开源版-全球免费多人视频聊天室,免费网络远程多人视频会议系统 ...
- 【Unity Shader学习笔记】实现反射与折射模拟水面、使用grabPass与环境贴图
文章目录 写在前面 一个水波效果 大致组成部分与对应的实现方案 交界线与深度贴图 折射效果与GrabPass 使用Cubemap与法线信息来模拟反射 在正确的地点创建对应的cubemap 通过贴图获取 ...
- 【黑马程序员】 学习笔记 - Java新技术 - 反射
----------------------android培训.java培训.期待与您交流!---------------------- Java新技术- 反射 反射就是把Java类中的各种成分映射成 ...
- Go核心开发学习笔记(廿九) —— 反射
反射使用的地方 序列化和反序列化时,如果希望序列时将结构体字段名称大写转换成小写,json:"xxx" 这里就用到了反射. 两个匿名函数变量,定义一个适配器函数用作统一处理接口: ...
- Mcad学习笔记之Microsoft Windows服务
相关文章导航 Sql Server2005 Transact-SQL 新兵器学习总结之-总结 Flex,Fms3相关文章索引 FlexAir开源版-全球免费多人视频聊天室,免费网络远程多人视频会议系统 ...
最新文章
- Google 在印度建立 AI 实验室,致力于农业、医疗、教育
- 使用Chrome浏览器和FF浏览器查看ajax发送以及从服务器传回的数据
- 监听器使用spring的bean
- 九章算法班L5 Linked List
- postman测试工具
- 【Pytorch神经网络理论篇】 24 神经网络中散度的应用:F散度+f-GAN的实现+互信息神经估计+GAN模型训练技巧
- Browser Core
- vmware快速搭建OpenStack云计算平台
- 新年新气象[xgluxv]
- FFmpeg之获取yuv分量(二十二)
- [Unity] 3D数学基础 - 2D旋转矩阵
- 学校面试计算机老师试题及答案,计算机面试问题及答案 (共2篇).doc
- 如何关闭计算机软件更新功能,如何关闭电脑自动更新功能
- 【渝粤教育】广东开放大学 管理会计 形成性考核 (33)
- 解决办法: Cannot resolve the collation conflict between Japanese_CI_AS and SQL_...
- Android开发对内存管理的学习总结
- oa系统服务器价格,oa软件系统价格
- 哈工大 2021春 计算机系统 大作业程序人生
- SkeyeVSS综合安防视频云服务H5无插件直播点播实现HEVC H265 300毫秒以内低延迟播放
- Ubuntu完全使用文档_我是亲民_新浪博客
热门文章
- 诡异的精度diff追查
- ES6代码转为ES5代码的在线转换工具
- html在服务器里怎么打开方式,html代码怎么在服务器里头执行?求高手解!
- MySQL------学习笔记1
- 第一章、开始groovy征程
- excel实现表格转置,降低表格维度、升高表格维度
- (四)Python查询12306余票:docopt实现参数的输入-----查询任意时间任意车站余票
- 怎么样才能使计算机题库打开不是wps,wps表格巧制电子试卷实现无纸化考试让电脑自动批改...
- Docker安装各类软件
- Google重磅发布云游戏平台,彻底告别游戏主机时代