这里的GO使用的版本是1.2
Go语言的基本语法的使用已经在前几篇陆陆续续学完了，下面可能想写一些Go的标准库的使用了。
先是reflect库。
reflect库的godoc在http://golang.org/pkg/reflect/
Type和Value
首先，reflect包有两个数据类型我们必须知道，一个是Type，一个是Value。
Type就是定义的类型的一个数据类型，Value是值的类型
具体的Type和Value里面包含的方法就要看文档了：
http://golang.org/pkg/reflect/
这里我写了个程序来理解Type和Value：
|
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
35
36
|
package main
import(
"fmt"
"reflect"
)
type MyStruct
struct
{
name
string
}
func (
this
*MyStruct)GetName()
string
{
return
this
.name
}
func main() {
s :=
"this is string"
fmt.Println(reflect.TypeOf(s))
fmt.Println(
"-------------------"
)
fmt.Println(reflect.ValueOf(s))
var
x float64 = 3.4
fmt.Println(reflect.ValueOf(x))
fmt.Println(
"-------------------"
)
a :=
new
(MyStruct)
a.name =
"yejianfeng"
typ := reflect.TypeOf(a)
fmt.Println(typ.NumMethod())
fmt.Println(
"-------------------"
)
b := reflect.ValueOf(a).MethodByName(
"GetName"
).Call([]reflect.Value{})
fmt.Println(b[0])
}
|
输出结果：
|
1
2
3
4
5
6
7
8
|
string
-------------------
this
is
string
<float64 value>
-------------------
1
-------------------
yejianfeng
|
补充，在Go version 1.5中会返回
|
1
2
3
4
5
6
7
8
|
string
-------------------
this
is
string
3.4
-------------------
1
-------------------
yejianfeng
|
这个程序看到几点：
1 TypeOf和ValueOf是获取Type和Value的方法
2 第三个b的定义实现了php中的string->method的方法，为什么返回的是reflect.Value[]数组呢？当然是因为Go的函数可以返回多个值的原因了。
Value的方法和属性
好了，我们看到Value的Type定义了这么多Set方法：
下面看这么个例子：
|
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
35
36
37
38
39
40
41
42
|
package main
import(
"fmt"
"reflect"
)
type MyStruct
struct
{
name
string
}
func (
this
*MyStruct)GetName()
string
{
return
this
.name
}
func main() {
fmt.Println(
"--------------"
)
var
a MyStruct
b :=
new
(MyStruct)
fmt.Println(reflect.ValueOf(a))
fmt.Println(reflect.ValueOf(b))
fmt.Println(
"--------------"
)
a.name =
"yejianfeng"
b.name =
"yejianfeng"
val := reflect.ValueOf(a).FieldByName(
"name"
)
//painc: val := reflect.ValueOf(b).FieldByName("name")
fmt.Println(val)
fmt.Println(
"--------------"
)
fmt.Println(reflect.ValueOf(a).FieldByName(
"name"
).CanSet())
fmt.Println(reflect.ValueOf(&(a.name)).Elem().CanSet())
fmt.Println(
"--------------"
)
var
c
string
=
"yejianfeng"
p := reflect.ValueOf(&c)
fmt.Println(p.CanSet())
//false
fmt.Println(p.Elem().CanSet())
//true
p.Elem().SetString(
"newName"
)
fmt.Println(c)
}
|
返回：
这段代码能有一些事情值得琢磨：
1 为什么a和b的ValueOf返回的是不一样的？
a是一个结构，b是一个指针。好吧，在Go中，指针的定义和C中是一样的。
2 reflect.ValueOf(a).FieldByName("name")
这是一个绕路的写法，其实和a.name是一样的意思，主要是要说明一下Value.FieldByName的用法
3 val := reflect.ValueOf(b).FieldByName("name") 是有error的，为什么？
b是一个指针，指针的ValueOf返回的是指针的Type，它是没有Field的，所以也就不能使用FieldByName
4 fmt.Println(reflect.ValueOf(a).FieldByName("name").CanSet())为什么是false?
看文档中的解释：
好吧，什么是addressable，and was not obtained by the use of unexported struct fields?
CanSet当Value是可寻址的时候，返回true，否则返回false
看到第二个c和p的例子，我们可以这么理解：
当前面的CanSet是一个指针的时候（p）它是不可寻址的，但是当是p.Elem()(实际上就是*p)，它就是可以寻址的
这个确实有点绕。
总而言之，reflect包是开发过程中几乎必备的包之一。能合理和熟练使用它对开发有很大的帮助。
20160829 补充：
Go 1.5的reflect Type方法可以看下面这个例子：
|
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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
|
package main
import (
"fmt"
"reflect"
)
type MyStruct
struct
{
name
string
}
func (
this
*MyStruct) GetName()
string
{
return
this
.name
}
type IStruct
interface
{
GetName()
string
}
func main() {
// TypeOf
s :=
"this is string"
fmt.Println(reflect.TypeOf(s))
// output: "string"
// object TypeOf
a :=
new
(MyStruct)
a.name =
"yejianfeng"
typ := reflect.TypeOf(a)
fmt.Println(typ)
// output: "*main.MyStruct"
fmt.Println(typ.Elem())
// output: "main.MyStruct"
// reflect.Type Base struct
fmt.Println(typ.NumMethod())
// 1
fmt.Println(typ.Method(0))
// {GetName func(*main.MyStruct) string <func(*main.MyStruct) string Value> 0}
fmt.Println(typ.Name())
// ""
fmt.Println(typ.PkgPath())
// ""
fmt.Println(typ.Size())
// 8
fmt.Println(typ.String())
// *main.MyStruct
fmt.Println(typ.Elem().String())
// main.MyStruct
fmt.Println(typ.Elem().FieldByIndex([]
int
{0}))
// {name main string 0 [0] false}
fmt.Println(typ.Elem().FieldByName(
"name"
))
// {name main string 0 [0] false} true
fmt.Println(typ.Kind() == reflect.Ptr)
// true
fmt.Println(typ.Elem().Kind() == reflect.Struct)
// true
fmt.Println(typ.Implements(reflect.TypeOf((*IStruct)(nil)).Elem()))
// true
fmt.Println(reflect.TypeOf(12.12).Bits())
// 64, 因为是float64
cha := make(chan
int
)
fmt.Println(reflect.TypeOf(cha).ChanDir())
// chan
var
fun func(x
int
, y ...float64)
string
var
fun2 func(x
int
, y float64)
string
fmt.Println(reflect.TypeOf(fun).IsVariadic())
// true
fmt.Println(reflect.TypeOf(fun2).IsVariadic())
// false
fmt.Println(reflect.TypeOf(fun).In(0))
// int
fmt.Println(reflect.TypeOf(fun).In(1))
// []float64
fmt.Println(reflect.TypeOf(fun).NumIn())
// 2
fmt.Println(reflect.TypeOf(fun).NumOut())
// 1
fmt.Println(reflect.TypeOf(fun).Out(0))
// string
mp := make(map[
string
]
int
)
mp[
"test1"
] = 1
fmt.Println(reflect.TypeOf(mp).Key())
//string
arr := [1]
string
{
"test"
}
fmt.Println(reflect.TypeOf(arr).Len())
// 1
fmt.Println(typ.Elem().NumField())
// 1
// MethodByName, Call
b := reflect.ValueOf(a).MethodByName(
"GetName"
).Call([]reflect.Value{})
fmt.Println(b[0])
// output: "yejianfeng"
}
|
本文转自轩脉刃博客园博客，原文链接：http://www.cnblogs.com/yjf512/archive/2012/06/10/2544391.html，如需转载请自行联系原作者
