Go基础编程:反射(reflect)

反射(reflection)

是指在程序运行期对程序本身进行访问和修改的能力。程序在编译时,变量被转换为内存地址,变量名不会被编译器写入到可执行部分。在运行程序时,程序无法获取自身的信息。支持反射的语言可以在程序编译期将变量的反射信息,如字段名称、类型信息、结构体信息等整合到可执行文件中,并给程序提供接口访问反射信息,这样就可以在程序运行期获取类型的反射信息,并且有能力修改它们。Go程序在运行期使用reflect包访问程序的反射信息。

C/C++语言没有支持反射功能,只能通过typeid提供非常弱化的程序运行时类型信息。Java、C#等语言都支持完整的反射功能。Lua、JavaScript类动态语言,由于其本身的语法特性就可以让代码在运行期访问程序自身的值和类型信息,因此不需要反射系统。Go程序的反射系统无法获取到一个可执行文件空间中或者是一个包中的所有类型信息,需要配合使用标准库中对应的词法、语法解析器和抽象语法树(AST)对源码进行扫描后获得这些信息。

类型与接口(Types and interfaces)

type MyInt int

var i int  //i 为int类型
var j MyInt  //j为MyInt类型
虽然i,j底层类型均为int,但它们属于不同类型,没有转换不能相互赋值。

接口类型 interface, 表示一系列方法集合,任意concrete (non-interface) value 只要实现了接口方法,便可赋值给interface

// Reader is the interface that wraps the basic Read method.
//Reader是包装基本读取方法的接口

type Reader interface {
    Read(p []byte) (n int, err error)
}

// Writer is the interface that wraps the basic Write method.
//Writer是包装基本写方法的接口
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)

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.
//保存在接口i. ValueOf(nil)中,返回0值
func ValueOf(i interface{}) Value //获取pair中的value

// TypeOf returns the reflection Type that represents the dynamic type of i.
//返回表示i的动态类型的反射类型。
// If i is a nil interface value, TypeOf returns nil.
//如果i是一个nil接口值,type返回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)

發表回覆

你的電郵地址並不會被公開。 必要欄位標記為 *