1. 介绍

文档地址：https://pkg.go.dev/reflect

Go 标准库 reflect 用于运行时的映射，使程序运行时可以检查和操纵任意类型的对象。例如，在运行时获取一个任意类型 interface{} 的对象，并获取它的动态类型。

获取对象的类型并使用不同的取值方法：

for _, v := range []any{"hi", 42, func() {}} {
	switch v := reflect.ValueOf(v); v.Kind() {
	case reflect.String:
		fmt.Println(v.String())
	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
		fmt.Println(v.Int())
	default:
		fmt.Printf("unhandled kind %s", v.Kind())
	}
}

获取变量的类型：

var x int
typ := reflect.TypeOf(x)
fmt.Println(typ)

根据函数名调用对应函数：

func add(a int, b int) int {
	return a + b
}
var FuncMap = map[string]interface{}{
	"add":   add,
}

funcName := "add"
f := reflect.ValueOf(FuncMap[funcName])
args := []reflect.Value{
	reflect.ValueOf(1),
	reflect.ValueOf(2),
}
ret := f.Call(args)
i := ret[0].Int()

根据方法名调用对应方法，需要注意方法需要是可导出方法才能被反射调用：

type People struct {
	name string
}
func (p *People) SetName(s string) {
	p.name = s
}
func (p *People) GetName() string {
	return p.name
}

p := People{}
setFunc := reflect.ValueOf(&p).MethodByName("SetName")
args := []reflect.Value{reflect.ValueOf("moondo")}
setFunc.Call(args)
getFunc := reflect.ValueOf(&p).MethodByName("GetName")
name := getFunc.Call([]reflect.Value{})[0].String()

获取结构体成员的标签：

type S struct {
	F string `species:"gopher" color:"blue"`
}

s := S{}
st := reflect.TypeOf(s)
field := st.Field(0)
fmt.Println(field.Tag.Get("color"), field.Tag.Get("species"))

2. 常量

const Ptr = Pointer

3. 类型

3.1 Kind

类型定义：

// Kind 类型
type Kind uint
const (
	Invalid Kind = iota
	Bool
	Int
	Int8
	Int16
	Int32
	Int64
	Uint
	Uint8
	Uint16
	Uint32
	Uint64
	Uintptr
	Float32
	Float64
	Complex64
	Complex128
	Array
	Chan
	Func
	Interface
	Map
	Pointer
	Slice
	String
	Struct
	UnsafePointer
)

方法：

// String 返回类型名称
func (k Kind) String() string

3.2 Type

类型定义：

// Type 类型的接口
type Type interface {

	// Align returns the alignment in bytes of a value of
	// this type when allocated in memory.
	Align() int

	// FieldAlign returns the alignment in bytes of a value of
	// this type when used as a field in a struct.
	FieldAlign() int

	// Method returns the i'th method in the type's method set.
	// Methods are sorted in lexicographic order.
	Method(int) Method

	// MethodByName returns the method with that name in the type's
	// method set and a boolean indicating if the method was found.
	MethodByName(string) (Method, bool)

	// NumMethod returns the number of methods accessible using Method.
	NumMethod() int

	// Name returns the type's name within its package for a defined type.
	Name() string

	// PkgPath returns a defined type's package path.
	PkgPath() string

	// Size returns the number of bytes needed to store a value of the given type.
	Size() uintptr

	// String returns a string representation of the type.
	String() string

	// Kind returns the specific kind of this type.
	Kind() Kind

	// Implements reports whether the type implements the interface type u.
	Implements(u Type) bool

	// AssignableTo reports whether a value of the type is assignable to type u.
	AssignableTo(u Type) bool

	// ConvertibleTo reports whether a value of the type is convertible to type u.
	ConvertibleTo(u Type) bool

	// Comparable reports whether values of this type are comparable.
	Comparable() bool

	// Bits returns the size of the type in bits.
	Bits() int

	// ChanDir returns a channel type's direction.
	ChanDir() ChanDir

	// IsVariadic reports whether a function type's final input parameter
	// is a "..." parameter. If so, t.In(t.NumIn() - 1) returns the parameter's
	// implicit actual type []T.
	IsVariadic() bool

	// Elem returns a type's element type.
	Elem() Type

	// Field returns a struct type's i'th field.
	Field(i int) StructField

	// FieldByIndex returns the nested field corresponding to the index sequence.
	FieldByIndex(index []int) StructField

	// FieldByName returns the struct field with the given name
	// and a boolean indicating if the field was found.
	FieldByName(name string) (StructField, bool)

	// FieldByNameFunc returns the struct field with a name
	// that satisfies the match function and a boolean indicating if
	// the field was found.
	FieldByNameFunc(match func(string) bool) (StructField, bool)

	// In returns the type of a function type's i'th input parameter.
	In(i int) Type

	// Key returns a map type's key type.
	Key() Type

	// Len returns an array type's length.
	Len() int

	// NumField returns a struct type's field count.
	NumField() int

	// NumIn returns a function type's input parameter count.
	NumIn() int

	// NumOut returns a function type's output parameter count.
	NumOut() int

	// Out returns the type of a function type's i'th output parameter.
	Out(i int) Type
}

方法：

// TypeOf 获取变量的类型
func TypeOf(i any) Type

// ArrayOf 给定长度和元素类型的数组的类型
func ArrayOf(length int, elem Type) Type

// ChanOf 给定方向和元素类型的通道的类型
func ChanOf(dir ChanDir, t Type) Type

// FuncOf 给定参数和返回类型的函数的类型
func FuncOf(in, out []Type, variadic bool) Type

// MapOf 给定key和元素类型的map的类型
func MapOf(key, elem Type) Type

// PointerTo 给定类型的指针的类型
func PointerTo(t Type) Type

// PtrTo 给定类型的指针的类型，等同PointerTo
func PtrTo(t Type) Type

// SliceOf 给定类型元素的slice的类型
func SliceOf(t Type) Type

// StructOf 给定成员类型的结构体的类型
func StructOf(fields []StructField) Type

3.3 Value

类型定义：

// Value 变量
type Value struct {
	// contains filtered or unexported fields
}

方法：

// Append 将多个变量x追加到slice s
func Append(s Value, x ...Value) Value

// AppendSlice 将slice t追加到slice s
func AppendSlice(s, t Value) Value

// Indirect 返回指针v指向的变量
func Indirect(v Value) Value

// MakeChan 创建不同的类型
func MakeChan(typ Type, buffer int) Value
func MakeFunc(typ Type, fn func(args []Value) (results []Value)) Value
func MakeMap(typ Type) Value
func MakeMapWithSize(typ Type, n int) Value
func MakeSlice(typ Type, len, cap int) Value

// New 创建指定类型的空指针
func New(typ Type) Value

// NewAt 创建指针并指向p
func NewAt(typ Type, p unsafe.Pointer) Value

// ValueOf 创建变量并用i初始化
func ValueOf(i any) Value

// Zero 创建指定类型变量并赋空值
func Zero(typ Type) Value

// Call 本身是一个函数，调用自己，传入in作为参数列表
func (v Value) Call(in []Value) []Value

// 还包括类型Value的许多方法，如判断能否转化为各种类型、设置各种类型的值、转为各种类型的值等

3.4 Method

类型定义：

// Method 方法
type Method struct {
	Name string    // method name
	PkgPath string // 对非导出的方法是包路径，对可导出的方法为空
	Type  Type     // method type
	Func  Value    // func with receiver as first argument
	Index int      // index for Type.Method
}

方法：

// IsExported 是否可导出（首字母大写）
func (m Method) IsExported() bool

3.5 StructField

类型定义：

// StructField 结构体的某个成员
type StructField struct {
	Name string         // field name
	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
}

方法：

// VisibleFields 返回可见的成员列表
func VisibleFields(t Type) []StructField

// IsExported 是否可导出（首字母大写）
func (f StructField) IsExported() bool

3.6 StructTag

类型定义：

// StructTag 结构体成员的标签
type StructTag string

方法：

// Get 获取标签对应key的值，key不存在返回空字符串
func (tag StructTag) Get(key string) string

// Lookup 获取标签对应key的值以及key是否存在
func (tag StructTag) Lookup(key string) (value string, ok bool)

3.7 MapIter

类型定义：

// MapIter map遍历的迭代器
type MapIter struct {
	// contains filtered or unexported fields
}

方法：

// Key 返回迭代器当前位置的key
func (iter *MapIter) Key() Value

// Value 返回迭代器当前位置的value
func (iter *MapIter) Value() Value

// Next 迭代器指向下一个元素，返回false表示遍历到尽头了
func (iter *MapIter) Next() bool

// Reset 将迭代器指向另一个map
func (iter *MapIter) Reset(v Value)

3.8 其他类型

类型定义：

// ChanDir 通道类型的方向
type ChanDir int
const (
	RecvDir ChanDir             = 1 << iota // <-chan
	SendDir                                 // chan<-
	BothDir = RecvDir | SendDir             // chan
)

// SelectCase select语句中的某个case
type SelectCase struct {
	Dir  SelectDir // direction of case
	Chan Value     // channel to use (for send or receive)
	Send Value     // value to send (for send)
}

// SelectDir 一个SelectCase的通信方向
type SelectDir int
const (
	SelectSend    SelectDir // case Chan <- Send
	SelectRecv              // case <-Chan:
	SelectDefault           // default
)

// SliceHeader 运行时的slice
type SliceHeader struct {
	Data uintptr
	Len  int
	Cap  int
}

// StringHeader 运行时的string
type StringHeader struct {
	Data uintptr
	Len  int
}

4. 函数

// Copy 变量复制，两个参数必须是同样元素类型的slice或数组，返回复制的元素个数
func Copy(dst, src Value) int

// DeepEqual 比较参数是否深度相等，对于函数同样是nil才是深度相等
func DeepEqual(x, y any) bool

// Swapper 返回一个函数，执行这个函数将调换现在的参数slice中的对应索引的元素
func Swapper(slice any) func(i, j int)

1. 介绍#

2. 常量#

3. 类型#

3.1 Kind#

3.2 Type#

3.3 Value#

3.4 Method#

3.5 StructField#

3.6 StructTag#

3.7 MapIter#

3.8 其他类型#

4. 函数#

1. 介绍

2. 常量

3. 类型

3.1 Kind

3.2 Type

3.3 Value

3.4 Method

3.5 StructField

3.6 StructTag

3.7 MapIter

3.8 其他类型

4. 函数