反射(reflection)是指在运行时,动态获取程序结构信息(元信息)的一种能力,是静态类型语言都支持的一种特性,如Java, golang等。这里主要详细介绍golang reflection相关知识
类型与接口(Types and interfaces)
type MyInt int var i int var j MyInt
i 为int类型,j为MyInt类型。虽然i,j底层类型均为int,但它们属于不同类型,没有转换不能相互赋值。
接口类型 interface, 表示一系列方法集合,任意concrete (non-interface) value 只要实现了接口方法,便可赋值给interface
// Reader is the interface that wraps the basic Read method. type Reader interface { Read(p []byte) (n int, err error) } // Writer is the interface that wraps the basic Write method. type Writer interface { Write(p []byte) (n int, err error) } var r io.Reader r = os.Stdin r = bufio.NewReader(r) r = new(bytes.Buffer) // and so on
r变量的静态类型为io.Reader,实际类型可能是File, Buffer类型
interface{} 特殊接口类型,没有任何方法,因此任何类型都可赋值给它
The representation of an interface
var r io.Reader r = new(bytes.Buffer)
r变量的具体类型是io.Reader,实际类型是bytes.Buffer,那么在运行时,golang是如何实现的呢?
一个interface类型的变量存储了2个信息, 一个值,类型对<value,type> pair:
赋给变量的值(concrete value)
变量值的类型描述符(value's type descriptor)
var r io.Reader tty, err := os.OpenFile("/dev/tty", os.O_RDWR, 0) if err != nil { return nil, err } r = tty
接口类型r 的<value, type> pair是(tty
, *os.File
)
当然r变量的value tty不仅仅实现了io.Reader接口中的Read方法,还实现了io.Writer中的Write方法,因此可以进行
类型断言(type assertion),试图将r 转换为io.Writer
var w io.Writer w = r.(io.Writer)
此时,接口变量w的<value,type>pair 为 (tty
, *os.File
),也就是说r,w 底层value是一样的,可以通过不同的type来暴露不同的方法出来。
继续讨论
var empty interface{} empty = w //此处不需要type assertion,因为任意类型都可以看作实现了empty interface的方法
接口变量empty的<value,type> pair 为 (tty
, *os.File
)
Reflection
1. Reflection goes from interface value to reflection object.(接口类型---> 反射类型(reflect.Value,reflect.Type))
反射,可以获取interface类型变量的具体信息(<value,concrete type>)
golang 反射包为reflect
// ValueOf returns a new Value initialized to the concrete value // stored in the interface i. ValueOf(nil) returns the zero Value. func ValueOf(i interface{}) Value //获取pair中的value // TypeOf returns the reflection Type that represents the dynamic type of i. // If i is a nil interface value, TypeOf returns nil. func TypeOf(i interface{}) Type //获取pair中的concrete type
eg:
var r io.Reader r = os.Stdin // <value, type> : <os.Stdin, *os.File> rValue := reflect.ValueOf(r) rType := reflect.TypeOf(r) fmt.Println("value:", rValue) fmt.Println("type :", rType) 输出: value: &{0xc04205a000} //指针 type : *os.File var f float64 f = 1.234 fmt.Println("f value:",reflect.ValueOf(f)) fmt.Println("f type :",reflect.TypeOf(f)) 输出: f value: 1.234 f type : float64
2. Reflection goes from reflection object to interface value. 反射类型(reflect.Value,reflect.Type) --> 接口类型
type User struct { Id int Name string Age int } func (u User) ReflectCallFunc() { fmt.Println("reflect learn") } user := User{1, "test", 13} var i interface{} i = user uValue := reflect.ValueOf(i) uType := reflect.TypeOf(i) fmt.Println("uValue: ",uValue) fmt.Println(uValue.Interface()) //转换为interface类型,unpack uValue.Interface().(User) fmt.Println(uValue.Type()) fmt.Println("uValue,string: ",uType.String()) fmt.Println("uType: ",uType.Name()) for i := 0; i < uType.NumField(); i++ { //获取field信息 field := uType.Field(i) value := uValue.Field(i).Interface() fmt.Printf("%s: %v = %v\n", field.Name, field.Type, value) } for i := 0; i < uType.NumMethod(); i++ {// 获取method信息 method := uType.Method(i) fmt.Printf("method[%d] = %s \n",i,method.Name) } fmt.Println(uValue.Kind()) fmt.Println(uType.Kind())
3. To modify a reflection object, the value must be settable. 通过反射修改变量
var x float64 = 3.4 v := reflect.ValueOf(x) fmt.Println("settability of v:", v.CanSet()) //print: settability of v: false v.SetFloat(7.1) // Error: will panic.
不可修改的原因:we pass a copy of x
to reflect.ValueOf
, so the interface value created as the argument to reflect.ValueOf
is a copy of x
, not x
itself
解决办法,传递指针!!
var x float64 = 3.4 p := reflect.ValueOf(&x) // Note: take the address of x. fmt.Println("type of p:", p.Type()) fmt.Println("settability of p:", p.CanSet()) print: type of p: *float64 settability of p: false //why ? p不可set,p指向的内容可set,p指向的内容即*p,如何获得p指向的内容?
reflect.Value 的Elem方法,可以获取value 指向的内容
v := p.Elem() fmt.Println("settability of v:", v.CanSet())//settability of v: true v.SetFloat(7.1) fmt.Println(v.Interface()) //7.1 fmt.Println(x) //7.1
4. Structs 反射操作实例
type T struct { A int B string } t := T{23, "skidoo"} s := reflect.ValueOf(&t).Elem() typeOfT := s.Type() for i := 0; i < s.NumField(); i++ { f := s.Field(i) fmt.Printf("%d:%v %s %s = %v\n", i, s.Kind(), typeOfT.Field(i).Name, f.Type(), f.Interface()) } fmt.Println("canSet:",s.CanSet()) s.Field(0).SetInt(24) s.Field(1).SetString("Sunset Strip") fmt.Println("after change: ",s.Interface())
5. 通过reflect 来调用方法
type User struct { Id int Name string Age int } func (u User) ReflectCallFunc() { fmt.Println("reflect learn") } func (u User) FuncHasArgs(name string, age int) { fmt.Println("FuncHasArgs name: ", name, ", age:", age, "and origal User.Name:", u.Name) } func (u User) FuncNoArgs() { fmt.Println("FuncNoArgs") } user := User{1, "test", 13} uValue := reflect.ValueOf(user) uType := reflect.TypeOf(user) m1 := uValue.MethodByName("FuncHasArgs") m2 := uValue.MethodByName("FuncNoArgs") m ,b := uType.MethodByName("FuncNoArgs") args := []reflect.Value{reflect.ValueOf("xiong"), reflect.ValueOf(30)} m1.Call(args) args = make([]reflect.Value,0) m2.Call(args) fmt.Println("m1:",m1) fmt.Println("m2:",m2) fmt.Printf("m:%#v,isfound:%v\n",m,b) fmt.Println(m1)
有疑问加站长微信联系(非本文作者)
![](https://static.golangjob.cn/static/img/footer.png?imageView2/2/w/280)