谈一谈Go的interface和reflect

在上一篇的go泛型编程里面简单地介绍了一下interface的使用,下面继续。

函数传参slice

先从一个问题开始:

有一个函数的输入参数是slice,但是slice里面的元素类型未知,如何来定义这个函数?

听上去很简单,很多人可能会写出下面的代码。

1
2
3
4
func MethodTakeinSlice(in []interface{}){...}
...
slice := []int{1,2,3}
MethodTakeinSlice(slice)

很遗憾,这样会得到一个错误信息:cannot use slice (type []int) as type []interface {} in argument to MethodTakeinSlice。一个简单的解决方案是写一个convert函数。

1
2
3
4
5
6
7
func convert(in []AnyType) (out []interface{}) {
out = make([]interface{}, len(in))
for i, v := range in {
out[i] = v
}
return
}

但这样相当于泛型的优势又没了,因为每一种特定类型都得做一个转换。这里就引入了go语言的另外一个特性reflect。

reflect

reflect,中文一般叫做反射。反射机制是指在运行时态能够调用对象的方法和属性。很多人比较熟悉的是Java的反射机制,其实go语言中也提供了反射机制,import reflect就可以使用。在go语言中,主要用在函数的参数是interface{}类型,运行时根据传入的参数的特定类型执行不同的动作。reflect针对很多数据类型都提供了一些方法以及属性。下面以Struct为例。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
file: src/reflect/type.go
// A StructField describes a single field in a struct.
type StructField struct {
// Name is the field name.
Name string
// PkgPath is the package path that qualifies a lower case (unexported)
// field name. It is empty for upper case (exported) field names.
// See https://golang.org/ref/spec#Uniqueness_of_identifiers
PkgPath string

Type Type // field type
Tag StructTag // field tag string
Offset uintptr // offset within struct, in bytes
Index []int // index sequence for Type.FieldByIndex
Anonymous bool // is an embedded field
}

这是reflect为Struct统一定义的属性,我们可以通过这些属性来操作struct,下面是一个简单的例子。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package main

import (
"fmt"
"reflect"
)

func main() {
kelu := Person{"kelu", 25}
t := reflect.TypeOf(kelu)
n := t.NumField()
for i := 0; i < n; i++ {
fmt.Println(t.Field(i).Name)
fmt.Println(t.Field(i).Type)
}
}
//output as follow
//name
//string
//age
//int

用reflect解决上面的问题

用reflect实现上面的问题无非就是通过reflect检验传入interface{}的类型,然后操作。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
package main

import (
"fmt"
"reflect"
)

type Person struct {
name string
age int
}

func Method(in interface{}) (ok bool) {
v := reflect.ValueOf(in)
if v.Kind() == reflect.Slice {
ok = true
}
else {
//panic
}

num := v.Len()
for i := 0; i < num; i++ {
fmt.Println(v.Index(i).Interface())
}
return ok
}

func main() {
s := []int{1, 3, 5, 7, 9}
b := []float64{1.2, 3.4, 5.6, 7.8}
Method(s)
Method(b)
}

其中refelct.Slice表示Slice,还有其他数据类型,一共25种。具体实现将在下面一节细讲。

reflect源码浅析

这部分内容将结合go语言的源码简单说一下reflect的实现,是作为为那些好奇心比较强的人写的。

reflect中数据类型表示
1
2
3
4
5
6
7
8
9
10
11
12
const (
Invalid Kind = iota
Bool
Int
Int8
...
Ptr
Slice
String
Struct
UnsafePointer
)

其中Bool为1,Int为2,依次递增1。可以用代码验证一下。

1
2
fmt.Printf("%d\n", reflect.Bool)	//output: 1
fmt.Println(reflect.Bool) //output: bool

下面为上面会输出bool呢,这是因为type.go中实现了String()方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
func (k Kind) String() string {
if int(k) < len(kindNames) {
return kindNames[k]
}
return "kind" + strconv.Itoa(int(k))
}
...
var kindNames = []string{
Invalid: "invalid",
Bool: "bool",
Int: "int",
Int8: "int8",
Int16: "int16",
Int32: "int32",
Int64: "int64",
...
Interface: "interface",
Map: "map",
Ptr: "ptr",
Slice: "slice",
String: "string",
Struct: "struct",
UnsafePointer: "unsafe.Pointer",
}

类型反射解析

我们按ValueOf()函数的流程走一遍。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
func ValueOf(i interface{}) Value {
if i == nil {
return Value{}
}

// TODO(rsc): Eliminate this terrible hack.
// In the call to unpackEface, i.typ doesn't escape,
// and i.word is an integer. So it looks like
// i doesn't escape. But really it does,
// because i.word is actually a pointer.
escapes(i)

return unpackEface(i)
}

escapes(i)是一个特殊处理,可以先不管,我们先看一下Value struct结构和unpackEface()函数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// unpackEface converts the empty interface i to a Value.
type Value struct {
// typ holds the type of the value represented by a Value.
typ *rtype

// Pointer-valued data or, if flagIndir is set, pointer to data.
// Valid when either flagIndir is set or typ.pointers() is true.
ptr unsafe.Pointer

//too much comment, delete it
flag
}
...
func unpackEface(i interface{}) Value {
e := (*emptyInterface)(unsafe.Pointer(&i))
// NOTE: don't read e.word until we know whether it is really a pointer or not.
t := e.typ
if t == nil {
return Value{}
}
f := flag(t.Kind())
if ifaceIndir(t) {
f |= flagIndir
}
return Value{t, unsafe.Pointer(e.word), f}
}

Value struct结构是核心,rtype是数据的底层实现,flag是元数据,可用用来表征Value的数据类型。unpackEface是把interface{}转换成Value数据。代码中ifaceIndir()用来确定是不是指针。
我们上面代码中还出现了Kind(),Kind()内不是实现的是kind(),从下面代码可以看出主要就是一个&的运算。这里还有个一个小细节。1<<flagKindWidth - 1在这里的结果为(1<<flagKindWidth) - 1,而C语言中的结果为1<<(flagKindWidth-1)。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
const (
flagKindWidth = 5 // there are 27 kinds
flagKindMask flag = 1<<flagKindWidth - 1
flagStickyRO flag = 1 << 5
flagEmbedRO flag = 1 << 6
flagIndir flag = 1 << 7
flagAddr flag = 1 << 8
flagMethod flag = 1 << 9
flagMethodShift = 10
flagRO flag = flagStickyRO | flagEmbedRO
)

func (f flag) kind() Kind {
return Kind(f & flagKindMask)
}

reference

Golang.org:pkg reflect, fmt, unsafe, etc
Golang take slices of any type as input parameter
Go reflect Example
Go unsafe.Pointer