1 // Copyright 2012 The Go Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style
3 // license that can be found in the LICENSE file.
17 for _
, v
:= range []interface{}{"hi", 42, func() {}} {
18 switch v
:= reflect
.ValueOf(v
); v
.Kind() {
20 fmt
.Println(v
.String())
21 case reflect
.Int
, reflect
.Int8
, reflect
.Int16
, reflect
.Int32
, reflect
.Int64
:
24 fmt
.Printf("unhandled kind %s", v
.Kind())
31 // unhandled kind func
34 func ExampleMakeFunc() {
35 // swap is the implementation passed to MakeFunc.
36 // It must work in terms of reflect.Values so that it is possible
37 // to write code without knowing beforehand what the types
39 swap
:= func(in
[]reflect
.Value
) []reflect
.Value
{
40 return []reflect
.Value
{in
[1], in
[0]}
43 // makeSwap expects fptr to be a pointer to a nil function.
44 // It sets that pointer to a new function created with MakeFunc.
45 // When the function is invoked, reflect turns the arguments
46 // into Values, calls swap, and then turns swap's result slice
47 // into the values returned by the new function.
48 makeSwap
:= func(fptr
interface{}) {
49 // fptr is a pointer to a function.
50 // Obtain the function value itself (likely nil) as a reflect.Value
51 // so that we can query its type and then set the value.
52 fn
:= reflect
.ValueOf(fptr
).Elem()
54 // Make a function of the right type.
55 v
:= reflect
.MakeFunc(fn
.Type(), swap
)
57 // Assign it to the value fn represents.
61 // Make and call a swap function for ints.
62 var intSwap
func(int, int) (int, int)
64 fmt
.Println(intSwap(0, 1))
66 // Make and call a swap function for float64s.
67 var floatSwap
func(float64, float64) (float64, float64)
69 fmt
.Println(floatSwap(2.72, 3.14))
76 func ExampleStructTag() {
78 F
string `species:"gopher" color:"blue"`
82 st
:= reflect
.TypeOf(s
)
84 fmt
.Println(field
.Tag
.Get("color"), field
.Tag
.Get("species"))
90 func ExampleStructTag_Lookup() {
92 F0
string `alias:"field_0"`
98 st
:= reflect
.TypeOf(s
)
99 for i
:= 0; i
< st
.NumField(); i
++ {
101 if alias
, ok
:= field
.Tag
.Lookup("alias"); ok
{
103 fmt
.Println("(blank)")
108 fmt
.Println("(not specified)")
118 func ExampleTypeOf() {
119 // As interface types are only used for static typing, a
120 // common idiom to find the reflection Type for an interface
121 // type Foo is to use a *Foo value.
122 writerType
:= reflect
.TypeOf((*io
.Writer
)(nil)).Elem()
124 fileType
:= reflect
.TypeOf((*os
.File
)(nil))
125 fmt
.Println(fileType
.Implements(writerType
))
131 func ExampleStructOf() {
132 typ
:= reflect
.StructOf([]reflect
.StructField
{
135 Type
: reflect
.TypeOf(float64(0)),
136 Tag
: `json:"height"`,
140 Type
: reflect
.TypeOf(int(0)),
145 v
:= reflect
.New(typ
).Elem()
146 v
.Field(0).SetFloat(0.4)
148 s
:= v
.Addr().Interface()
150 w
:= new(bytes
.Buffer
)
151 if err
:= json
.NewEncoder(w
).Encode(s
); err
!= nil {
155 fmt
.Printf("value: %+v\n", s
)
156 fmt
.Printf("json: %s", w
.Bytes())
158 r
:= bytes
.NewReader([]byte(`{"height":1.5,"age":10}`))
159 if err
:= json
.NewDecoder(r
).Decode(s
); err
!= nil {
162 fmt
.Printf("value: %+v\n", s
)
165 // value: &{Height:0.4 Age:2}
166 // json: {"height":0.4,"age":2}
167 // value: &{Height:1.5 Age:10}