go反射----1类型

OStack程序员社区-中国程序员成长平台 › 门户 › 编程› Go›Go教程

原作者: [db:作者] 来自: [db:来源] 收藏邀请

雨痕老师《Go语言学习笔记》

反射( reflect )让我们能在运行期探知对象的类型信息和内存结构，这从一定程度上弥补了静态语言在动态行为上的不足。同时，反射还是元编程的重要手段。

和C数据结构一样，Go对象头部并没有类型指针，通过其自身是无法在运行期获知任何类型相关信息的。反射操作所需的全部信息都源自接口变量。接口变量除储存自身类型外，还会保存实际对象的类型数据。

func TypeOf(i interface{}) Type
func ValueOf(i interface{}) Value

这两个反射入口函数，会将任何传入的对象转换为接口类型。

在面对类型时，需要区分Type和Kind。前者表示真实类型( 静态类型 )，后者表示其基础结构( 底层类型 )类别。

package main

import (
	"fmt"
	"reflect"
)

type X int

func main() {
	var a X = 100
	t := reflect.TypeOf(a)
	fmt.Println(t.Name(), t.Kind())
}

输出：

X int

所以在类型判断上，须选择正确的方式。

package main

import (
	"fmt"
	"reflect"
)

type X int
type Y int

func main() {
	var a, b X = 100, 200
	var c Y = 300
	ta, tb, tc := reflect.TypeOf(a), reflect.TypeOf(b), reflect.TypeOf(c)
	fmt.Println(ta == tb, ta == tc)
	fmt.Println(ta.Kind() == tc.Kind())
}

输出：

true false
true

除通过实际对象获取类型外，也可以直接构造一些基础符合类型。

package main

import (
	"fmt"
	"reflect"
)

func main() {
	a := reflect.ArrayOf(10, reflect.TypeOf(byte(0)))
	m := reflect.MapOf(reflect.TypeOf(""), reflect.TypeOf(0))
	fmt.Println(a, m)
}

输出：

[10]uint8 map[string]int

传入对象应区分基类型和指针类型，因为他们并不属于同一类型。

package main

import (
	"fmt"
	"reflect"
)

func main() {
	x := 100
	tx, tp := reflect.TypeOf(x), reflect.TypeOf(&x)
	fmt.Println(tx, tp, tx == tp)
	fmt.Println(tx.Kind(), tp.Kind())
	fmt.Println(tx == tp.Elem())
}

输出：

int *int false
int ptr
true

方法Elem返回指针、数组、切片、字典（值）或通道的基类型。

package main

import (
	"fmt"
	"reflect"
)

func main() {
	fmt.Println(reflect.TypeOf(map[string]int{}).Elem())
	fmt.Println(reflect.TypeOf([]int32{}).Elem())
}

输出：

int
int32

只有在获取结构体指针的基类型后，才能遍历它的字段。

package main

import (
	"fmt"
	"reflect"
)

type user struct {
	name string
	age  int
}
type manager struct {
	user
	title string
}

func main() {
	var m manager
	t := reflect.TypeOf(&m)
	if t.Kind() == reflect.Ptr { //获取指针的基类型
		t = t.Elem()
	}
	for i := 0; i < t.NumField(); i++ {
		f := t.Field(i)
		fmt.Println(f.Name, f.Type, f.Offset)
		if f.Anonymous { //输出匿名字段结构
			for x := 0; x < f.Type.NumField(); x++ {
				af := f.Type.Field(x)
				fmt.Println("	", af.Name, af.Type)
			}
		}
	}
}

输出：

user main.user 0
         name string
         age int
title string 24

对于匿名字段，可用多级索引（按定义顺序）直接访问。

package main

import (
	"fmt"
	"reflect"
)

type user struct {
	name string
	age  int
}
type manager struct {
	user
	title string
}

func main() {
	var m manager
	t := reflect.TypeOf(m)
	name, _ := t.FieldByName("name") //按名称查找
	fmt.Println(name.Name, name.Type)
	age := t.FieldByIndex([]int{0, 1}) //按多级索引查找
	fmt.Println(age.Name, age.Type)
}

输出：

name string
age int

FieldByName 不支持多级名称，如有同名遮蔽，须通过匿名字段的二次获取

同样地，输出方法集时，一样区分基类型和指针类型。 ```golang package main

import (
"fmt"
"reflect"
)

type A int
type B struct {
A
}

func (a A) Av() {}
func (a *A) Ap() {}

func (b B) Bv() {}
func (b *B) Bp() {}

func main() {
var b B
t := reflect.TypeOf(&b)
s := []reflect.Type{t, t.Elem()}
for _, v := range s {
fmt.Println(v, "????
//注意，方法名为小写时，反射不出来
//通过NumMethod()反射出方法的个数
for i := 0; i < v.NumMethod(); i++ {
fmt.Println(" ", v.Method(i))
}
}
}

输出：

main.B :
{Ap func(main.B) <func(main.B) Value> 0}
{Av func(main.B) <func(main.B) Value> 1}
{Bp func(main.B) <func(main.B) Value> 2}
{Bv func(main.B) <func(*main.B) Value> 3}
main.B :
{Av func(main.B) <func(main.B) Value> 0}
{Bv func(main.B) <func(main.B) Value> 1}

有一点和想象的不同，反射能探知当前包或外包的非导出结构成员
```golang
package main

import (
	"fmt"
	"net/http"
	"reflect"
)

func main() {
	var s http.Server
	t := reflect.TypeOf(s)
	for i := 0; i < t.NumField(); i++ {
		fmt.Println(t.Field(i).Name)
	}
}

输出：

Addr
Handler
ReadTimeout
WriteTimeout
TLSConfig
MaxHeaderBytes
TLSNextProto
ConnState
ErrorLog
disableKeepAlives
nextProtoOnce
nextProtoErr

相对reflect而言，当前包和外包都是“外包”。*_*

可用反射提取struct tag，还能自动分解。其常用于ORM映射，或数据格式验证。 ```golang package main

import (
"fmt"
"reflect"
)

type user struct {
name string field:"name" type:"varchar(50)"
age int field:"age" type:"int"
}

func main() {
var u user
t := reflect.TypeOf(u)
for i := 0; i < t.NumField(); i++ {
f := t.Field(i)
fmt.Printf("%s:%s %s\n", f.Name, f.Tag.Get("field"), f.Tag.Get("type"))
}
}

输出：

name:name varchar(50)
age:age int

辅助判断方法 Implements,ConvertibleTo,AssignableTo都是运行期进行动态调用和赋值所必需的。
```golang
package main

import (
	"fmt"
	"reflect"
)

type X int

func (X) String() string {
	return ""
}
func main() {
	var a X
	t := reflect.TypeOf(a)

	//Implements 不能直接使用类型作为参数，导致这种用法非常别扭
	st := reflect.TypeOf((*fmt.Stringer)(nil)).Elem()
	fmt.Println(t.Implements(st))
	it := reflect.TypeOf(0)
	fmt.Println(t.ConvertibleTo(it))
	fmt.Println(t.AssignableTo(st), t.AssignableTo(it))
}

输出：