Package reflect

import "reflect"
Overview
Index
Examples

Overview ▾

包反射实现了运行时反射,从而允许程序处理任意类型的对象. 典型的用法是使用静态类型interface {}来获取值,并通过调用TypeOf来提取其动态类型信息,该类型将返回Type.

调用ValueOf返回一个代表运行时数据的Value. 零采用一个类型,并返回一个表示该类型的零值的值.

See "The Laws of Reflection" for an introduction to reflection in Go: https://golang.org/doc/articles/laws_of_reflection.html

Index ▾

func Copy(dst, src Value) int
func DeepEqual(x, y interface{}) bool
func Swapper(slice interface{}) func(i, j int)
type ChanDir
    func (d ChanDir) String() string
type Kind
    func (k Kind) String() string
type MapIter
    func (it *MapIter) Key() Value
    func (it *MapIter) Next() bool
    func (it *MapIter) Value() Value
type Method
type SelectCase
type SelectDir
type SliceHeader
type StringHeader
type StructField
type StructTag
    func (tag StructTag) Get(key string) string
    func (tag StructTag) Lookup(key string) (value string, ok bool)
type Type
    func ArrayOf(count int, elem Type) Type
    func ChanOf(dir ChanDir, t Type) Type
    func FuncOf(in, out []Type, variadic bool) Type
    func MapOf(key, elem Type) Type
    func PtrTo(t Type) Type
    func SliceOf(t Type) Type
    func StructOf(fields []StructField) Type
    func TypeOf(i interface{}) Type
type Value
    func Append(s Value, x ...Value) Value
    func AppendSlice(s, t Value) Value
    func Indirect(v Value) Value
    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
    func New(typ Type) Value
    func NewAt(typ Type, p unsafe.Pointer) Value
    func Select(cases []SelectCase) (chosen int, recv Value, recvOK bool)
    func ValueOf(i interface{}) Value
    func Zero(typ Type) Value
    func (v Value) Addr() Value
    func (v Value) Bool() bool
    func (v Value) Bytes() []byte
    func (v Value) Call(in []Value) []Value
    func (v Value) CallSlice(in []Value) []Value
    func (v Value) CanAddr() bool
    func (v Value) CanInterface() bool
    func (v Value) CanSet() bool
    func (v Value) Cap() int
    func (v Value) Close()
    func (v Value) Complex() complex128
    func (v Value) Convert(t Type) Value
    func (v Value) Elem() Value
    func (v Value) Field(i int) Value
    func (v Value) FieldByIndex(index []int) Value
    func (v Value) FieldByName(name string) Value
    func (v Value) FieldByNameFunc(match func(string) bool) Value
    func (v Value) Float() float64
    func (v Value) Index(i int) Value
    func (v Value) Int() int64
    func (v Value) Interface() (i interface{})
    func (v Value) InterfaceData() [2]uintptr
    func (v Value) IsNil() bool
    func (v Value) IsValid() bool
    func (v Value) IsZero() bool
    func (v Value) Kind() Kind
    func (v Value) Len() int
    func (v Value) MapIndex(key Value) Value
    func (v Value) MapKeys() []Value
    func (v Value) MapRange() *MapIter
    func (v Value) Method(i int) Value
    func (v Value) MethodByName(name string) Value
    func (v Value) NumField() int
    func (v Value) NumMethod() int
    func (v Value) OverflowComplex(x complex128) bool
    func (v Value) OverflowFloat(x float64) bool
    func (v Value) OverflowInt(x int64) bool
    func (v Value) OverflowUint(x uint64) bool
    func (v Value) Pointer() uintptr
    func (v Value) Recv() (x Value, ok bool)
    func (v Value) Send(x Value)
    func (v Value) Set(x Value)
    func (v Value) SetBool(x bool)
    func (v Value) SetBytes(x []byte)
    func (v Value) SetCap(n int)
    func (v Value) SetComplex(x complex128)
    func (v Value) SetFloat(x float64)
    func (v Value) SetInt(x int64)
    func (v Value) SetLen(n int)
    func (v Value) SetMapIndex(key, elem Value)
    func (v Value) SetPointer(x unsafe.Pointer)
    func (v Value) SetString(x string)
    func (v Value) SetUint(x uint64)
    func (v Value) Slice(i, j int) Value
    func (v Value) Slice3(i, j, k int) Value
    func (v Value) String() string
    func (v Value) TryRecv() (x Value, ok bool)
    func (v Value) TrySend(x Value) bool
    func (v Value) Type() Type
    func (v Value) Uint() uint64
    func (v Value) UnsafeAddr() uintptr
type ValueError
    func (e *ValueError) Error() string
Bugs

Examples

Kind
MakeFunc
StructOf
StructTag
StructTag.Lookup
TypeOf

Package files

deepequal.go makefunc.go swapper.go type.go value.go

func Copy

func Copy(dst, src Value) int

复制将src的内容复制到dst中,直到填满dst或用尽src. 它返回复制的元素数. Dst和src每个都必须具有片或数组,而dst和src必须具有相同的元素类型.

作为一种特殊情况,如果dst的元素类型为Uint8,则src可以具有String类型.

func DeepEqual

func DeepEqual(x, y interface{}) bool

DeepEqual报告x和y是否"深度相等",定义如下. 如果满足以下情况之一,则两个相同类型的值将非常相等. 不同类型的值永远不会完全相等.

当数组的相应元素深度相等时,数组值深度相等.

如果结构的值对应的字段(导出的和未导出的)都非常相等,则该值非常相等.

如果两者均为零,则Func值将完全相等; 否则,它们就不会完全平等.

如果接口值具有完全相等的具体值,则它们是高度相等的.

当满足以下所有条件时,映射值深度相等:它们都是nil或都不是nil,它们具有相同的长度,并且它们是相同的映射对象或它们的对应键(使用Go相等匹配)映射到相等的值.

如果指针值使用Go的==运算符相等,或者它们指向深度相等的值,则它们的深度相等.

当满足以下所有条件时,切片值将完全相等:它们均为nil或均为非nil,它们具有相同的长度,并且它们指向同一基础数组的相同初始条目(即&x [0 ] ==&y [0])或它们相应的元素(最大长度)相等. 请注意,非nil空片和nil片(例如[] byte {}和[] byte(nil))并不完全相等.

如果使用Go的==运算符,其他值(数字,布尔值,字符串和通道)将完全相等.

In general DeepEqual is a recursive relaxation of Go's == operator. However, this idea is impossible to implement without some inconsistency. Specifically, it is possible for a value to be unequal to itself, either because it is of func type (uncomparable in general) or because it is a floating-point NaN value (not equal to itself in floating-point comparison), or because it is an array, struct, or interface containing such a value. On the other hand, pointer values are always equal to themselves, even if they point at or contain such problematic values, because they compare equal using Go's == operator, and that is a sufficient condition to be deeply equal, regardless of content. DeepEqual has been defined so that the same short-cut applies to slices and maps: if x and y are the same slice or the same map, they are deeply equal regardless of content.

当DeepEqual遍历数据值时,可能会发现一个循环. DeepEqual在第二次及以后比较两个之前比较过的指针值时,会将这些值视为相等,而不是检查它们所指向的值. 这样可以确保DeepEqual终止.

func Swapper 1.8

func Swapper(slice interface{}) func(i, j int)

交换器返回一个函数,该函数交换提供的片中的元素.

如果提供的接口不是切片,则交换器会出现混乱.

type ChanDir

ChanDir表示通道类型的方向.

type ChanDir int
const (
    RecvDir ChanDir             = 1 << iota // <-chan
    SendDir                                 // chan<-
    BothDir = RecvDir | SendDir             // chan
)

func (ChanDir) String

func (d ChanDir) String() string

type 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
    Ptr
    Slice
    String
    Struct
    UnsafePointer
)

Example

hi
42
unhandled kind func

func (Kind) String

func (k Kind) String() string

字符串返回k的名称.

type MapIter 1.12

MapIter是用于遍历地图的迭代器. 请参见Value.MapRange.

type MapIter struct {
    // contains filtered or unexported fields
}

func (*MapIter) Key 1.12

func (it *MapIter) Key() Value

Key返回迭代器当前映射条目的密钥.

func (*MapIter) Next 1.12

func (it *MapIter) Next() bool

下一步前进地图迭代器并报告是否还有另一个条目. 迭代器用尽时返回false; 随后调用"键","值"或"下一步"将惊慌.

func (*MapIter) Value 1.12

func (it *MapIter) Value() Value

值返回迭代器当前映射条目的值.

type Method

方法代表一种方法.

type Method struct {
    // Name is the method name.
    // PkgPath is the package path that qualifies a lower case (unexported)
    // method name. It is empty for upper case (exported) method names.
    // The combination of PkgPath and Name uniquely identifies a method
    // in a method set.
    // See https://golang.org/ref/spec#Uniqueness_of_identifiers
    Name    string
    PkgPath string

    Type  Type  // method type
    Func  Value // func with receiver as first argument
    Index int   // index for Type.Method
}

type SelectCase 1.1

SelectCase描述了选择操作中的单个案例. 案件的种类取决于Dir,通讯方向.

如果Dir为SelectDefault,则案例代表默认案例. Chan和Send必须为零值.

如果Dir是SelectSend,则大小写表示发送操作. 通常,Chan的基础值必须是一个渠道,Send的基础值必须可分配给渠道的元素类型. 作为一种特殊情况,如果Chan为零值,则忽略大小写,并且字段Send也将被忽略,并且可以为零或非零.

如果Dir是SelectRecv,则大小写表示接收操作. 通常,Chan的基础值必须是一个渠道,Send必须是零值. 如果Chan为零值,则忽略大小写,但Send必须仍为零值. 选择接收操作时,选择返回返回接收到的值.

type SelectCase struct {
    Dir  SelectDir // direction of case
    Chan Value     // channel to use (for send or receive)
    Send Value     // value to send (for send)
}

type SelectDir 1.1

SelectDir描述选择案例的通信方向.

type SelectDir int
const (
    SelectSend    SelectDir // case Chan <- Send
    SelectRecv              // case <-Chan:
    SelectDefault           // default
)

type SliceHeader

SliceHeader是切片的运行时表示形式. 它不能安全或便携地使用,其表示形式可能会在以后的版本中更改. 此外,"数据"字段不足以保证不会对其进行垃圾回收,因此程序必须保留一个单独的,正确键入的指向基础数据的指针.

type SliceHeader struct {
    Data uintptr
    Len  int
    Cap  int
}

type StringHeader

StringHeader是字符串的运行时表示形式. 它不能安全或便携地使用,其表示形式可能会在以后的版本中更改. 此外,"数据"字段不足以保证不会对其进行垃圾回收,因此程序必须保留一个单独的,正确键入的指向基础数据的指针.

type StringHeader struct {
    Data uintptr
    Len  int
}

type StructField

StructField描述结构中的单个字段.

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
}

type StructTag

StructTag是struct字段中的标签字符串.

按照惯例,标签字符串是由空格分隔的键:"值"对的串联. 每个键都是一个非空字符串,由非控制字符组成,除了空格(U + 0020''),引号(U + 0022'"')和冒号(U + 003A':').每个值都用引号引起来使用U + 0022'"'字符和Go字符串文字语法.

type StructTag string

Example

blue gopher

func (StructTag) Get

func (tag StructTag) Get(key string) string

Get返回与标签字符串中的key关联的值. 如果标签中没有这样的键,则Get返回空字符串. 如果标签不具有常规格式,则未指定Get返回的值. 若要确定是否将标记明确设置为空字符串,请使用Lookup.

func (StructTag) Lookup 1.7

func (tag StructTag) Lookup(key string) (value string, ok bool)

查找返回与标签字符串中的键关联的值. 如果密钥存在于标签中,则返回值(可能为空). 否则,返回值将为空字符串. ok返回值报告该值是否在标记字符串中显式设置. 如果标记不具有常规格式,则未指定Lookup返回的值.

Example

field_0
(blank)
(not specified)

type Type 1.4

Type是Go类型的表示.

Not all methods apply to all kinds of types. Restrictions, if any, are noted in the documentation for each method. Use the Kind method to find out the kind of type before calling kind-specific methods. Calling a method inappropriate to the kind of type causes a run-time panic.

类型值是可比较的,例如==运算符,因此它们可用作映射键. 如果两个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.
    // It panics if i is not in the range [0, NumMethod()).
    //
    // For a non-interface type T or *T, the returned Method's Type and Func
    // fields describe a function whose first argument is the receiver.
    //
    // For an interface type, the returned Method's Type field gives the
    // method signature, without a receiver, and the Func field is nil.
    //
    // Only exported methods are accessible and they 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.
    //
    // For a non-interface type T or *T, the returned Method's Type and Func
    // fields describe a function whose first argument is the receiver.
    //
    // For an interface type, the returned Method's Type field gives the
    // method signature, without a receiver, and the Func field is nil.
    MethodByName(string) (Method, bool)

    // NumMethod returns the number of exported methods in the type's method set.
    NumMethod() int

    // Name returns the type's name within its package for a defined type.
    // For other (non-defined) types it returns the empty string.
    Name() string

    // PkgPath returns a defined type's package path, that is, the import path
    // that uniquely identifies the package, such as "encoding/base64".
    // If the type was predeclared (string, error) or not defined (*T, struct{},
    // []int, or A where A is an alias for a non-defined type), the package path
    // will be the empty string.
    PkgPath() string

    // Size returns the number of bytes needed to store
    // a value of the given type; it is analogous to unsafe.Sizeof.
    Size() uintptr

    // String returns a string representation of the type.
    // The string representation may use shortened package names
    // (e.g., base64 instead of "encoding/base64") and is not
    // guaranteed to be unique among types. To test for type identity,
    // compare the Types directly.
    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.
    // It panics if the type's Kind is not one of the
    // sized or unsized Int, Uint, Float, or Complex kinds.
    Bits() int

    // ChanDir returns a channel type's direction.
    // It panics if the type's Kind is not Chan.
    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.
    //
    // For concreteness, if t represents func(x int, y ... float64), then
    //
    //	t.NumIn() == 2
    //	t.In(0) is the reflect.Type for "int"
    //	t.In(1) is the reflect.Type for "[]float64"
    //	t.IsVariadic() == true
    //
    // IsVariadic panics if the type's Kind is not Func.
    IsVariadic() bool

    // Elem returns a type's element type.
    // It panics if the type's Kind is not Array, Chan, Map, Ptr, or Slice.
    Elem() Type

    // Field returns a struct type's i'th field.
    // It panics if the type's Kind is not Struct.
    // It panics if i is not in the range [0, NumField()).
    Field(i int) StructField

    // FieldByIndex returns the nested field corresponding
    // to the index sequence. It is equivalent to calling Field
    // successively for each index i.
    // It panics if the type's Kind is not Struct.
    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 considers the fields in the struct itself
    // and then the fields in any embedded structs, in breadth first order,
    // stopping at the shallowest nesting depth containing one or more
    // fields satisfying the match function. If multiple fields at that depth
    // satisfy the match function, they cancel each other
    // and FieldByNameFunc returns no match.
    // This behavior mirrors Go's handling of name lookup in
    // structs containing embedded fields.
    FieldByNameFunc(match func(string) bool) (StructField, bool)

    // In returns the type of a function type's i'th input parameter.
    // It panics if the type's Kind is not Func.
    // It panics if i is not in the range [0, NumIn()).
    In(i int) Type

    // Key returns a map type's key type.
    // It panics if the type's Kind is not Map.
    Key() Type

    // Len returns an array type's length.
    // It panics if the type's Kind is not Array.
    Len() int

    // NumField returns a struct type's field count.
    // It panics if the type's Kind is not Struct.
    NumField() int

    // NumIn returns a function type's input parameter count.
    // It panics if the type's Kind is not Func.
    NumIn() int

    // NumOut returns a function type's output parameter count.
    // It panics if the type's Kind is not Func.
    NumOut() int

    // Out returns the type of a function type's i'th output parameter.
    // It panics if the type's Kind is not Func.
    // It panics if i is not in the range [0, NumOut()).
    Out(i int) Type
    // contains filtered or unexported methods
}

func ArrayOf 1.5

func ArrayOf(count int, elem Type) Type

ArrayOf返回具有给定计数和元素类型的数组类型. 例如,如果t表示int,则ArrayOf(5,t)表示[5] int.

如果结果类型大于可用的地址空间,则ArrayOf会发生混乱.

func ChanOf 1.1

func ChanOf(dir ChanDir, t Type) Type

ChanOf返回具有给定方向和元素类型的通道类型. 例如,如果t表示int,则ChanOf(RecvDir,t)表示<-chan int.

gc运行时对通道元素类型施加了64 kB的限制. 如果t的大小等于或超过此限制,ChanOf会惊慌.

func FuncOf 1.5

func FuncOf(in, out []Type, variadic bool) Type

FuncOf返回具有给定参数和结果类型的函数类型. 例如,如果k表示int,e表示字符串,则FuncOf([] Type {k},[] Type {e},false)表示func(int)字符串.

可变参数控制该函数是否可变. 如果in [len(in)-1]不代表切片并且可变参数为true,则FuncOf会发生恐慌.

func MapOf 1.1

func MapOf(key, elem Type) Type

MapOf返回具有给定键和元素类型的地图类型. 例如,如果k表示int,e表示字符串,则MapOf(k,e)表示map [int] string.

如果键类型不是有效的地图键类型(即,如果它不实现Go的==运算符),则MapOf会发生混乱.

func PtrTo

func PtrTo(t Type) Type

PtrTo returns the pointer type with element t. For example, if t represents type Foo, PtrTo(t) represents *Foo.

func SliceOf 1.1

func SliceOf(t Type) Type

SliceOf返回元素类型为t的切片类型. 例如,如果t表示int,则SliceOf(t)表示[] int.

func StructOf 1.7

func StructOf(fields []StructField) Type

StructOf返回包含字段的结构类型. 偏移和索引字段将被忽略,并像编译器一样进行计算.

如果传递未导出的StructFields,StructOf当前不会为嵌入式字段和紧急情况生成包装方法. 这些限制可能会在将来的版本中解除.

Example

value: &{Height:0.4 Age:2}
json:  {"height":0.4,"age":2}
value: &{Height:1.5 Age:10}

func TypeOf

func TypeOf(i interface{}) Type

TypeOf返回表示i的动态类型的反射类型. 如果i是nil接口值,则TypeOf返回nil.

Example

true

type Value

值是Go值的反射接口.

并非所有方法都适用于所有类型的值. 在每种方法的文档中都注明了限制(如果有). 在调用特定于种类的方法之前,请使用Kind方法找出值的种类. 调用不适合该类型的方法会导致运行时恐慌.

零值表示无值. 它的IsValid方法返回false,其Kind方法返回Invalid,其String方法返回" <invalid Value>",所有其他方法均会出现紧急情况. 大多数函数和方法从不返回无效值. 如果是这样,则其文档会明确说明条件.

一个值可以被多个goroutine并发使用,前提是可以将基础Go值同时用于等效的直接操作.

要比较两个值,请比较接口方法的结果. 在两个值上使用==不会比较它们表示的基础值.

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

func Append

func Append(s Value, x ...Value) Value

Append将值x附加到切片s上,并返回结果切片. 与Go中一样,每个x的值必须可分配给slice的元素类型.

func AppendSlice

func AppendSlice(s, t Value) Value

AppendSlice将切片t附加到切片s上,并返回结果切片. 切片s和t必须具有相同的元素类型.

func Indirect

func Indirect(v Value) Value

间接返回v指向的值. 如果v是nil指针,则Indirect返回零值. 如果v不是指针,则Indirect返回v.

func MakeChan

func MakeChan(typ Type, buffer int) Value

MakeChan用指定的类型和缓冲区大小创建一个新通道.

func MakeFunc 1.1

func MakeFunc(typ Type, fn func(args []Value) (results []Value)) Value

MakeFunc返回给定类型的新函数,该函数包装函数fn. 在调用时,该新函数将执行以下操作:

- converts its arguments to a slice of Values.
- runs results := fn(args).
- returns the results as a slice of Values, one per formal result.

实现fn可以假设参数Value slice具有typ指定的参数的数量和类型. 如果typ描述了可变函数,则最终值本身就是代表可变参数的切片,就像可变函数的主体一样. fn返回的结果Value slice必须具有typ指定的结果的数量和类型.

Value.Call方法允许调用者根据Values调用类型化的函数. 相反,MakeFunc允许调用者根据值来实现类型化的函数.

该文档的"示例"部分包括如何使用MakeFunc为不同类型构建交换函数的说明.

Example

1 0
3.14 2.72

func MakeMap

func MakeMap(typ Type) Value

MakeMap创建具有指定类型的新地图.

func MakeMapWithSize 1.9

func MakeMapWithSize(typ Type, n int) Value

MakeMapWithSize会为大约n个元素创建一个具有指定类型和初始空间的新地图.

func MakeSlice

func MakeSlice(typ Type, len, cap int) Value

MakeSlice为指定的切片类型,长度和容量创建一个新的零初始化切片值.

func New

func New(typ Type) Value

新建返回一个值,该值表示指向指定类型的新零值的指针. 也就是说,返回的值的类型为PtrTo(typ).

func NewAt

func NewAt(typ Type, p unsafe.Pointer) Value

NewAt返回一个值,该值表示指向指定类型值的指针,并使用p作为该指针.

func Select 1.1

func Select(cases []SelectCase) (chosen int, recv Value, recvOK bool)

Select执行案例列表所描述的选择操作. 类似于Go select语句,它阻塞直到至少一种情况可以继续进行,做出统一的伪随机选择然后执行该情况. 它返回所选案例的索引,如果该案例是接收操作,则返回接收到的值和一个布尔值,该布尔值指示该值是否对应于通道上的发送(而不是因为通道关闭而接收到的零值).

func ValueOf

func ValueOf(i interface{}) Value

ValueOf返回一个新的Value,初始化为存储在接口i中的具体值. ValueOf(nil)返回零值.

func Zero

func Zero(typ Type) Value

零返回一个值,该值表示指定类型的零值. 结果与Value结构的零值不同,后者根本不代表任何值. 例如,Zero(TypeOf(42))返回带有Kind Int且值为0的值.返回的值既不可寻址,也不可设置.

func (Value) Addr

func (v Value) Addr() Value

Addr返回一个表示v的地址的指针值.如果CanAddr()返回false,则会恐慌. Addr通常用于获取指向struct字段或slice元素的指针,以便调用需要指针接收器的方法.

func (Value) Bool

func (v Value) Bool() bool

布尔返回v的基础值. 如果v的种类不是布尔,它会感到恐慌.

func (Value) Bytes

func (v Value) Bytes() []byte

字节返回v的基础值. 如果v的基础值不是一个字节片,则会感到恐慌.

func (Value) Call

func (v Value) Call(in []Value) []Value

Call使用输入参数in调用函数v.例如,如果len(in)== 3,则v.Call(in)表示Go调用v(in [0],in [1],in [2]) . 如果v的Kind不是Func,请致电恐慌. 它将输出结果作为值返回. 与Go中一样,每个输入参数必须可分配给函数的相应输入参数的类型. 如果v是可变参数函数,则Call会自己创建可变参数切片参数,并复制相应的值.

func (Value) CallSlice

func (v Value) CallSlice(in []Value) []Value

CallSlice使用输入参数in调用可变参数函数v,将切片in [len(in)-1]分配给v的最终可变参数. 例如,如果len(in)== 3,则v.CallSlice(in)表示Go调用v(in [0],in [1],in [2] ...). 如果v的Kind不是Func或v不是可变参数,CallSlice会感到恐慌. 它将输出结果作为值返回. 与Go中一样,每个输入参数必须可分配给函数的相应输入参数的类型.

func (Value) CanAddr

func (v Value) CanAddr() bool

CanAddr报告是否可以通过Addr获取值的地址. 这样的值称为可寻址的. 如果值是切片的元素,可寻址数组的元素,可寻址结构的字段或取消引用指针的结果,则该值是可寻址的. 如果CanAddr返回false,则调用Addr会惊慌.

func (Value) CanInterface

func (v Value) CanInterface() bool

CanInterface报告是否可以在不惊慌的情况下使用Interface.

func (Value) CanSet

func (v Value) CanSet() bool

CanSet报告v的值是否可以更改. 值只能是可寻址的,并且不是通过使用未导出的结构字段获得的,才可以更改. 如果CanSet返回false,则调用Set或任何特定于类型的setter(例如SetBool,SetInt)会感到恐慌.

func (Value) Cap

func (v Value) Cap() int

上限返回v的容量. 如果v的Kind不是Array,Chan或Slice,它会感到恐慌.

func (Value) Close

func (v Value) Close()

Close关闭通道v.如果v的Kind不是Chan,它就会慌张.

func (Value) Complex

func (v Value) Complex() complex128

Complex返回v的基础值,为complex128. 如果v的Kind不是Complex64或Complex128,则会感到恐慌

func (Value) Convert 1.1

func (v Value) Convert(t Type) Value

Convert返回将值v转换为类型t. 如果通常的Go转换规则不允许将值v转换为类型t,请转换恐慌.

func (Value) Elem

func (v Value) Elem() Value

Elem返回接口v包含的值或指针v指向的值. 如果v的种类不是Interface或Ptr,它会感到恐慌. 如果v为零,它将返回零值.

func (Value) Field

func (v Value) Field(i int) Value

Field返回结构v的第i个字段.如果v的Kind不是Struct或i不在范围内,它将恐慌.

func (Value) FieldByIndex

func (v Value) FieldByIndex(index []int) Value

FieldByIndex返回与索引对应的嵌套字段. 如果v的Kind不是struct,它会感到恐慌.

func (Value) FieldByName

func (v Value) FieldByName(name string) Value

FieldByName返回具有给定名称的struct字段. 如果未找到任何字段,则返回零值. 如果v的Kind不是struct,它会感到恐慌.

func (Value) FieldByNameFunc

func (v Value) FieldByNameFunc(match func(string) bool) Value

FieldByNameFunc返回具有满足match函数名称的struct字段. 如果v的Kind不是struct,它会感到恐慌. 如果未找到任何字段,则返回零值.

func (Value) Float

func (v Value) Float() float64

Float返回v的基础值,作为float64. 如果v的Kind不是Float32或Float64,它将感到恐慌

func (Value) Index

func (v Value) Index(i int) Value

索引返回v的第i个元素. 如果v的Kind不是Array,Slice或String或i超出范围,它会感​​到恐慌.

func (Value) Int

func (v Value) Int() int64

Int返回v的基础值,作为int64. 如果v的Kind不是Int,Int8,Int16,Int32或Int64,它会感到恐慌.

func (Value) Interface

func (v Value) Interface() (i interface{})

接口返回v的当前值作为接口{}. 它等效于:

var i interface{} = (v's underlying value)

如果值是通过访问未导出的结构字段获得的,它将感到恐慌.

func (Value) InterfaceData

func (v Value) InterfaceData() [2]uintptr

InterfaceData returns the interface v's value as a uintptr pair. It panics if v's Kind is not Interface.

func (Value) IsNil

func (v Value) IsNil() bool

IsNil报告其参数v是否为nil. 参数必须是chan,func,interface,map,pointer或slice值; 如果不是,则IsNil感到恐慌. 请注意,IsNil并不总是等同于Go中与nil的常规比较. 例如,如果v是通过使用未初始化的接口变量i调用ValueOf来创建的,则i == nil为true,但v.IsNil会感到恐慌,因为v为零值.

func (Value) IsValid

func (v Value) IsValid() bool

IsValid报告v是否表示一个值. 如果v为零值,则返回false. 如果IsValid返回false,则所有其他方法(字符串恐慌除外). 大多数函数和方法从不返回无效值. 如果是这样,则其文档会明确说明条件.

func (Value) IsZero 1.13

func (v Value) IsZero() bool

IsZero报告v是否为其类型的零值. 如果参数无效,则会感到恐慌.

func (Value) Kind

func (v Value) Kind() Kind

种类返回v的种类. 如果v为零值(IsValid返回false),则Kind返回Invalid.

func (Value) Len

func (v Value) Len() int

Len返回v的长度. 如果v的Kind不是Array,Chan,Map,Slice或String,它会感到恐慌.

func (Value) MapIndex

func (v Value) MapIndex(key Value) Value

MapIndex返回与地图v中的键关联的值.如果v的Kind不是Map,它将恐慌. 如果在映射中未找到键或v表示无映射,则返回零值. 与Go中一样,键的值必须可分配给地图的键类型.

func (Value) MapKeys

func (v Value) MapKeys() []Value

MapKeys返回一个切片,其中包含未指定顺序的地图中存在的所有键. 如果v的Kind不是Map,它将感到恐慌. 如果v表示一个nil映射,它将返回一个空切片.

func (Value) MapRange 1.12

func (v Value) MapRange() *MapIter

MapRange返回地图的范围迭代器. 如果v的Kind不是Map,它将感到恐慌.

调用下一步以前进迭代器,并调用键/值访问每个条目. 迭代器用尽时,Next返回false. MapRange遵循与范围语句相同的迭代语义.

Example:

iter := reflect.ValueOf(m).MapRange()
for iter.Next() {
	k := iter.Key()
	v := iter.Value()
	...
}

func (Value) Method

func (v Value) Method(i int) Value

方法返回与v的第i个方法相对应的函数值. 返回函数上的Call的参数不应包含接收方; 返回的函数将始终使用v作为接收者. 如果i超出范围或v是nil接口值,则方法会出现紧急情况.

func (Value) MethodByName

func (v Value) MethodByName(name string) Value

MethodByName返回与具有给定名称的v方法相对应的函数值. 返回函数上的Call的参数不应包含接收方; 返回的函数将始终使用v作为接收者. 如果未找到任何方法,它将返回零值.

func (Value) NumField

func (v Value) NumField() int

NumField返回struct v中的字段数.如果v的Kind不是Struct,它将感到恐慌.

func (Value) NumMethod

func (v Value) NumMethod() int

NumMethod返回值的方法集中导出的方法的数量.

func (Value) OverflowComplex

func (v Value) OverflowComplex(x complex128) bool

OverflowComplex报告complex128 x是否不能用v的类型表示. 如果v的Kind不是Complex64或Complex128,则会感到恐慌.

func (Value) OverflowFloat

func (v Value) OverflowFloat(x float64) bool

OverflowFloat报告float64 x是否不能用v的类型表示. 如果v的Kind不是Float32或Float64,则会感到恐慌.

func (Value) OverflowInt

func (v Value) OverflowInt(x int64) bool

OverflowInt报告int64 x是否不能用v的类型表示. 如果v的Kind不是Int,Int8,Int16,Int32或Int64,它会感到恐慌.

func (Value) OverflowUint

func (v Value) OverflowUint(x uint64) bool

OverflowUint报告uint64 x是否不能用v的类型表示. 如果v的Kind不是Uint,Uintptr,Uint8,Uint16,Uint32或Uint64,它会惊慌.

func (Value) Pointer

func (v Value) Pointer() uintptr

指针将v的值作为uintptr返回. 它返回uintptr而不是unsafe.Pointer,因此使用反射的代码无法在不显式导入不安全包的情况下获取不安全. 如果v的Kind不是Chan,Func,Map,Ptr,Slice或UnsafePointer,它将惊慌.

如果v的Kind为Func,则返回的指针是基础代码指针,但不一定足以唯一地标识单个函数. 唯一的保证是,当且仅当v为nil func值时,结果为零.

如果v的Kind为Slice,则返回的指针指向该切片的第一个元素. 如果切片为nil,则返回值为0.如果切片为空但非nil,则返回值为非零.

func (Value) Recv

func (v Value) Recv() (x Value, ok bool)

Recv从通道v接收并返回一个值.如果v的Kind不是Chan,它会感到恐慌. 接收将阻塞,直到准备好值为止. 如果值x对应于通道上的发送,则布尔值ok为true,如果由于通道关闭而接收到零值,则为false.

func (Value) Send

func (v Value) Send(x Value)

Send在通道v上发送x.如果v的类型不是Chan或x的类型与v的元素类型不同,则它会感到恐慌. 与Go中一样,x的值必须可分配给通道的元素类型.

func (Value) Set

func (v Value) Set(x Value)

Set将x赋给值v.如果CanSet返回false,它将感到恐慌. 与Go中一样,x的值必须可分配给v的类型.

func (Value) SetBool

func (v Value) SetBool(x bool)

SetBool设置v的基础值. 如果v的Kind不是Bool或CanSet()为false,它会感到恐慌.

func (Value) SetBytes

func (v Value) SetBytes(x []byte)

SetBytes设置v的基础值. 如果v的基础值不是一个字节片,则会感到恐慌.

func (Value) SetCap 1.2

func (v Value) SetCap(n int)

SetCap将v的容量设置为n. 如果v的Kind不是Slice或n小于length或大于slice的容量,则会出现紧急情况.

func (Value) SetComplex

func (v Value) SetComplex(x complex128)

SetComplex将v的基础值设置为x. 如果v的Kind不是Complex64或Complex128,或者CanSet()为false,它会惊慌.

func (Value) SetFloat

func (v Value) SetFloat(x float64)

SetFloat将v的基础值设置为x. 如果v的Kind不是Float32或Float64,或者CanSet()为false,它会感到恐慌.

func (Value) SetInt

func (v Value) SetInt(x int64)

SetInt将v的基础值设置为x. 如果v的Kind不是Int,Int8,Int16,Int32或Int64,或者CanSet()为false,它会感到恐慌.

func (Value) SetLen

func (v Value) SetLen(n int)

SetLen将v的长度设置为n. 如果v的Kind不是Slice,或者n为负或大于slice的容量,则会发生恐慌.

func (Value) SetMapIndex

func (v Value) SetMapIndex(key, elem Value)

SetMapIndex将与地图v中的key关联的元素设置为elem. 如果v的Kind不是Map,它将感到恐慌. 如果elem为零值,则SetMapIndex将从映射中删除键. 否则,如果v持有nil贴图,则SetMapIndex会惊慌. 与Go中一样,键的elem必须可分配给地图的键类型,并且elem的值必须可分配给地图的键类型.

func (Value) SetPointer

func (v Value) SetPointer(x unsafe.Pointer)

SetPointer将unsafe.Pointer值v设置为x. 如果v的Kind不是UnsafePointer,则会感到恐慌.

func (Value) SetString

func (v Value) SetString(x string)

SetString将v的基础值设置为x. 如果v的Kind不是String或CanSet()为false,它会惊慌.

func (Value) SetUint

func (v Value) SetUint(x uint64)

SetUint将v的基础值设置为x. 如果v的Kind不是Uint,Uintptr,Uint8,Uint16,Uint32或Uint64,或者CanSet()为false,它会惊慌.

func (Value) Slice

func (v Value) Slice(i, j int) Value

Slice返回v [i:j]. 如果v的Kind不是Array,Slice或String,或者v是不可寻址的数组,或者索引超出范围,它会感​​到恐慌.

func (Value) Slice3 1.2

func (v Value) Slice3(i, j, k int) Value

Slice3是切片操作的3索引形式:它返回v [i:j:k]. 如果v的Kind不是Array或Slice,或者v是不可寻址的数组,或者索引超出范围,它就会感到恐慌.

func (Value) String

func (v Value) String() string

String以字符串形式返回字符串v的基础值. 由于Go的String方法约定,String是一种特殊情况. 与其他吸气剂不同,如果v的Kind不是String,它不会惊慌. 相反,它返回形式为" <T value>"的字符串,其中T是v的类型. fmt软件包特别对待Values. 它不会隐式调用其String方法,而是打印它们持有的具体值.

func (Value) TryRecv

func (v Value) TryRecv() (x Value, ok bool)

TryRecv尝试从通道v接收值,但不会阻塞. 如果v's Kind不是Chan,就会感到恐慌. 如果接收方提供了一个值,则x是已传输的值,而ok是正确的. 如果接收无法完成而没有阻塞,则x为零值,ok为假. 如果关闭通道,则x为通道元素类型的零值,ok为false.

func (Value) TrySend

func (v Value) TrySend(x Value) bool

TrySend尝试在通道v上发送x,但不会阻塞. 如果v's Kind不是Chan,就会感到恐慌. 它报告该值是否已发送. 与Go中一样,x的值必须可分配给通道的元素类型.

func (Value) Type

func (v Value) Type() Type

Type返回v的类型.

func (Value) Uint

func (v Value) Uint() uint64

Uint以uint64返回v的基础值. 如果v的Kind不是Uint,Uintptr,Uint8,Uint16,Uint32或Uint64,它会惊慌.

func (Value) UnsafeAddr

func (v Value) UnsafeAddr() uintptr

UnsafeAddr返回指向v的数据的指针. 适用于还导入"不安全"程序包的高级客户端. 如果v无法寻址,它会感到恐慌.

type ValueError

在不支持Value的Value方法上调用Value方法时,会发生ValueError. 在每种方法的说明中都记录了这种情况.

type ValueError struct {
    Method string
    Kind   Kind
}

func (*ValueError) Error

func (e *ValueError) Error() string

Bugs

by  ICOPY.SITE