矮马高手
什么是反射
大多数时候，go中的变量，类型和函数非常简单直接。当需要一个类型、变量或者是函数时，可以直接定义它们：
type foo struct {
a int
b string
}
var x foo
func dosomething(f foo) {
fmt.println(f.a, f.b)
}
但是有时你希望在运行时使用变量的在编写程序时还不存在的信息。比如你正在尝试将文件或网络请求中的数据映射到变量中。或者你想构建一个适用于不同类型的工具。在这种情况下，你需要使用反射。反射使您能够在运行时检查类型。它还允许您在运行时检查，修改和创建变量，函数和结构体。
go中的反射是基于三个概念构建的：类型，种类和值（types kinds values）。标准库中的reflect包提供了 go 反射的实现。
反射变量类型
首先让我们看一下类型。你可以使用反射来调用函数vartype := reflect.typeof(var)来获取变量var的类型。这将返回类型为reflect.type的变量，该变量具有获取定义时变量的类型的各种信息的方法集。下面我们来看一下常用的获取类型信息的方法。
我们要看的第一个方法是name()。这将返回变量类型的名称。某些类型（例如切片或指针）没有名称，此方法会返回空字符串。
下一个方法，也是我认为第一个真正非常有用的方法是kind()。type是由kind组成的---kind 是切片，映射，指针，结构，接口，字符串，数组，函数，int或其他某种原始类型的抽象表示。要理解type和kind之间的差异可能有些棘手，但是请你以这种方式来思考。如果定义一个名为foo的结构体，则kind为struct，类型为foo。
使用反射时要注意的一件事：反射包中的所有内容都假定你知道自己在做什么，并且如果使用不正确，许多函数和方法调用都会引起 panic。例如，如果你在reflect.type上调用与当前类型不同的类型关联的方法，您的代码将会panic。
如果变量是指针，映射，切片，通道或数组变量，则可以使用vartype.elem()找出指向或包含的值的类型。
如果变量是结构体，则可以使用反射来获取结构体中的字段数，并从每个字段上获取reflect.structfield结构体。 reflection.structfield为您提供了字段的名称，标号，类型和结构体标签。其中标签信息对应reflect.structtag类型的字符串，并且它提供了get方法用于解析和根据特定key提取标签信息中的子串。
下面是一个简单的示例，用于输出各种变量的类型信息：
type foo struct {
a int `tag1:"first tag" tag2:"second tag"`
b string
}
func main() {
sl := []int{1, 2, 3}
greeting := "hello"
greetingptr := &greeting
f := foo{a: 10, b: "salutations"}
fp := &f
sltype := reflect.typeof(sl)
gtype := reflect.typeof(greeting)
grptype := reflect.typeof(greetingptr)
ftype := reflect.typeof(f)
fptype := reflect.typeof(fp)
examiner(sltype, 0)
examiner(gtype, 0)
examiner(grptype, 0)
examiner(ftype, 0)
examiner(fptype, 0)
}
func examiner(t reflect.type, depth int) {
fmt.println(strings.repeat("\t", depth), "type is", t.name(), "and kind is", t.kind())
switch t.kind() {
case reflect.array, reflect.chan, reflect.map, reflect.ptr, reflect.slice:
fmt.println(strings.repeat("\t", depth+1), "contained type:")
examiner(t.elem(), depth+1)
case reflect.struct:
for i := 0; i < t.numfield(); i++ {
f := t.field(i)
fmt.println(strings.repeat("\t", depth+1), "field", i+1, "name is", f.name, "type is", f.type.name(), "and kind is", f.type.kind())
if f.tag != "" {
fmt.println(strings.repeat("\t", depth+2), "tag is", f.tag)
fmt.println(strings.repeat("\t", depth+2), "tag1 is", f.tag.get("tag1"), "tag2 is", f.tag.get("tag2"))
}
}
}
}
变量的类型输出如下：
type is and kind is slice
contained type:
type is int and kind is int
type is string and kind is string
type is and kind is ptr
contained type:
type is string and kind is string
type is foo and kind is struct
field 1 name is a type is int and kind is int
tag is tag1:"first tag" tag2:"second tag"
tag1 is first tag tag2 is second tag
field 2 name is b type is string and kind is string
type is and kind is ptr
contained type:
type is foo and kind is struct
field 1 name is a type is int and kind is int
tag is tag1:"first tag" tag2:"second tag"
tag1 is first tag tag2 is second tag
field 2 name is b type is string and kind is string
run in go playground: https://play.golang.org/p/lz97yauhxx
使用反射创建新实例
除了检查变量的类型外，还可以使用反射来读取，设置或创建值。首先，需要使用refval := reflect.valueof(var) 为变量创建一个reflect.value实例。如果希望能够使用反射来修改值，则必须使用refptrval := reflect.valueof(＆var);获得指向变量的指针。如果不这样做，则可以使用反射来读取该值，但不能对其进行修改。
一旦有了reflect.value实例就可以使用type()方法获取变量的reflect.type。
如果要修改值，请记住它必须是一个指针，并且必须首先对其进行解引用。使用refptrval.elem().set(newrefval)来修改值，并且传递给set()的值也必须是reflect.value。
如果要创建一个新值，可以使用函数newptrval := reflect.new(vartype)来实现，并传入一个reflect.type。这将返回一个指针值，然后可以像上面那样使用elem().set()对其进行修改。
最后，你可以通过调用interface()方法从reflect.value回到普通变量值。由于go没有泛型，因此变量的原始类型会丢失；该方法返回类型为interface{}的值。如果创建了一个指针以便可以修改该值，则需要使用elem().interface()解引用反射的指针。在这两种情况下，都需要将空接口转换为实际类型才能使用它。
下面的代码来演示这些概念：
type foo struct {
a int `tag1:"first tag" tag2:"second tag"`
b string
}
func main() {
greeting := "hello"
f := foo{a: 10, b: "salutations"}
gval := reflect.valueof(greeting)
// not a pointer so all we can do is read it
fmt.println(gval.interface())
gpval := reflect.valueof(&greeting)
// it's a pointer, so we can change it, and it changes the underlying variable
gpval.elem().setstring("goodbye")
fmt.println(greeting)
ftype := reflect.typeof(f)
fval := reflect.new(ftype)
fval.elem().field(0).setint(20)
fval.elem().field(1).setstring("greetings")
f2 := fval.elem().interface().(foo)
fmt.printf("%+v, %d, %s\n", f2, f2.a, f2.b)
}
他们的输出如下：
hello
goodbye
{a:20 b:greetings}, 20, greetings
run in go playground https://play.golang.org/p/pfceyfzqz8
反射创建引用类型的实例
除了生成内置类型和用户定义类型的实例之外，还可以使用反射来生成通常需要make函数的实例。可以使用reflect.makeslice，reflect.makemap和reflect.makechan函数制作切片，map或通道。在所有情况下，都提供一个reflect.type，然后获取一个reflect.value，可以使用反射对其进行操作，或者可以将其分配回一个标准变量。
func main() {
// 定义变量
intslice := make([]int, 0)
mapstringint := make(map[string]int)
// 获取变量的 reflect.type
slicetype := reflect.typeof(intslice)
maptype := reflect.typeof(mapstringint)
// 使用反射创建类型的新实例
intslicereflect := reflect.makeslice(slicetype, 0, 0)
mapreflect := reflect.makemap(maptype)
// 将创建的新实例分配回一个标准变量
v := 10
rv := reflect.valueof(v)
intslicereflect = reflect.append(intslicereflect, rv)
intslice2 := intslicereflect.interface().([]int)
fmt.println(intslice2)
k := "hello"
rk := reflect.valueof(k)
mapreflect.setmapindex(rk, rv)
mapstringint2 := mapreflect.interface().(map[string]int)
fmt.println(mapstringint2)
}
使用反射创建函数
反射不仅仅可以为存储数据创造新的地方。还可以使用reflect.makefunc函数使用reflect来创建新函数。该函数期望我们要创建的函数的reflect.type，以及一个闭包，其输入参数为[]reflect.value类型，其返回类型也为[] reflect.value类型。下面是一个简单的示例，它为传递给它的任何函数创建一个定时包装器：
func maketimedfunction(f interface{}) interface{} {
rf := reflect.typeof(f)
if rf.kind() != reflect.func {
panic("expects a function")
}
vf := reflect.valueof(f)
wrapperf := reflect.makefunc(rf, func(in []reflect.value) []reflect.value {
start := time.now()
out := vf.call(in)
end := time.now()
fmt.printf("calling %s took %v\n", runtime.funcforpc(vf.pointer()).name(), end.sub(start))
return out
})
return wrapperf.interface()
}
func timeme() {
fmt.println("starting")
time.sleep(1 * time.second)
fmt.println("ending")
}
func timemetoo(a int) int {
fmt.println("starting")
time.sleep(time.duration(a) * time.second)
result := a * 2
fmt.println("ending")
return result
}
func main() {
timed := maketimedfunction(timeme).(func())
timed()
timedtoo := maketimedfunction(timemetoo).(func(int) int)
fmt.println(timedtoo(2))
}
你可以在goplayground运行代码https://play.golang.org/p/qz8ttfzzgx并看到输出如下：
starting ending calling main.timeme took 1s starting ending calling main.timemetoo took 2s 4
反射是每个go开发人员都应了解并学会的强大工具。但是使用他们可以用来做什么呢？在下一篇博客文章中，我将探讨现有库中反射的一些用法，并使用反射来创建一些新的东西。
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。
