...
Run Format

Source file src/reflect/example_test.go

Documentation: reflect

     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.
     4  
     5  package reflect_test
     6  
     7  import (
     8  	"bytes"
     9  	"encoding/json"
    10  	"fmt"
    11  	"io"
    12  	"os"
    13  	"reflect"
    14  )
    15  
    16  func ExampleMakeFunc() {
    17  	// swap is the implementation passed to MakeFunc.
    18  	// It must work in terms of reflect.Values so that it is possible
    19  	// to write code without knowing beforehand what the types
    20  	// will be.
    21  	swap := func(in []reflect.Value) []reflect.Value {
    22  		return []reflect.Value{in[1], in[0]}
    23  	}
    24  
    25  	// makeSwap expects fptr to be a pointer to a nil function.
    26  	// It sets that pointer to a new function created with MakeFunc.
    27  	// When the function is invoked, reflect turns the arguments
    28  	// into Values, calls swap, and then turns swap's result slice
    29  	// into the values returned by the new function.
    30  	makeSwap := func(fptr interface{}) {
    31  		// fptr is a pointer to a function.
    32  		// Obtain the function value itself (likely nil) as a reflect.Value
    33  		// so that we can query its type and then set the value.
    34  		fn := reflect.ValueOf(fptr).Elem()
    35  
    36  		// Make a function of the right type.
    37  		v := reflect.MakeFunc(fn.Type(), swap)
    38  
    39  		// Assign it to the value fn represents.
    40  		fn.Set(v)
    41  	}
    42  
    43  	// Make and call a swap function for ints.
    44  	var intSwap func(int, int) (int, int)
    45  	makeSwap(&intSwap)
    46  	fmt.Println(intSwap(0, 1))
    47  
    48  	// Make and call a swap function for float64s.
    49  	var floatSwap func(float64, float64) (float64, float64)
    50  	makeSwap(&floatSwap)
    51  	fmt.Println(floatSwap(2.72, 3.14))
    52  
    53  	// Output:
    54  	// 1 0
    55  	// 3.14 2.72
    56  }
    57  
    58  func ExampleStructTag() {
    59  	type S struct {
    60  		F string `species:"gopher" color:"blue"`
    61  	}
    62  
    63  	s := S{}
    64  	st := reflect.TypeOf(s)
    65  	field := st.Field(0)
    66  	fmt.Println(field.Tag.Get("color"), field.Tag.Get("species"))
    67  
    68  	// Output:
    69  	// blue gopher
    70  }
    71  
    72  func ExampleStructTag_Lookup() {
    73  	type S struct {
    74  		F0 string `alias:"field_0"`
    75  		F1 string `alias:""`
    76  		F2 string
    77  	}
    78  
    79  	s := S{}
    80  	st := reflect.TypeOf(s)
    81  	for i := 0; i < st.NumField(); i++ {
    82  		field := st.Field(i)
    83  		if alias, ok := field.Tag.Lookup("alias"); ok {
    84  			if alias == "" {
    85  				fmt.Println("(blank)")
    86  			} else {
    87  				fmt.Println(alias)
    88  			}
    89  		} else {
    90  			fmt.Println("(not specified)")
    91  		}
    92  	}
    93  
    94  	// Output:
    95  	// field_0
    96  	// (blank)
    97  	// (not specified)
    98  }
    99  
   100  func ExampleTypeOf() {
   101  	// As interface types are only used for static typing, a
   102  	// common idiom to find the reflection Type for an interface
   103  	// type Foo is to use a *Foo value.
   104  	writerType := reflect.TypeOf((*io.Writer)(nil)).Elem()
   105  
   106  	fileType := reflect.TypeOf((*os.File)(nil))
   107  	fmt.Println(fileType.Implements(writerType))
   108  
   109  	// Output:
   110  	// true
   111  }
   112  
   113  func ExampleStructOf() {
   114  	typ := reflect.StructOf([]reflect.StructField{
   115  		{
   116  			Name: "Height",
   117  			Type: reflect.TypeOf(float64(0)),
   118  			Tag:  `json:"height"`,
   119  		},
   120  		{
   121  			Name: "Age",
   122  			Type: reflect.TypeOf(int(0)),
   123  			Tag:  `json:"age"`,
   124  		},
   125  	})
   126  
   127  	v := reflect.New(typ).Elem()
   128  	v.Field(0).SetFloat(0.4)
   129  	v.Field(1).SetInt(2)
   130  	s := v.Addr().Interface()
   131  
   132  	w := new(bytes.Buffer)
   133  	if err := json.NewEncoder(w).Encode(s); err != nil {
   134  		panic(err)
   135  	}
   136  
   137  	fmt.Printf("value: %+v\n", s)
   138  	fmt.Printf("json:  %s", w.Bytes())
   139  
   140  	r := bytes.NewReader([]byte(`{"height":1.5,"age":10}`))
   141  	if err := json.NewDecoder(r).Decode(s); err != nil {
   142  		panic(err)
   143  	}
   144  	fmt.Printf("value: %+v\n", s)
   145  
   146  	// Output:
   147  	// value: &{Height:0.4 Age:2}
   148  	// json:  {"height":0.4,"age":2}
   149  	// value: &{Height:1.5 Age:10}
   150  }
   151  

View as plain text