go反射----1类型

声明：文章内容取自雨痕老师《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, "

go反射----1类型

声明：文章内容取自雨痕老师《Go语言学习笔记》

推荐阅读