1.方法和类型的反射

反射可以在运行时检查类型和变量，例如它的大小、方法和 动态 的调用这些方法。这对于没有源代码的包尤其有用。这是一个强大的工具，除非真得有必要，否则应当避免使用或小心使用。

reflect.TypeOf 和 reflect.ValueOf，返回被检查对象的类型和值
Interface() 方法可以得到还原（接口）值
Kind 总是返回底层类型

  1. package main
  3. import (
  4.     "fmt"
  5.     "reflect"
  6. )
  8. func main() {
  9.     var x float64 = 3.4
  10.     fmt.Println("type:", reflect.TypeOf(x))
  11.     v := reflect.ValueOf(x)
  12.     fmt.Println("value:", v)
  13.     fmt.Println("type:", v.Type())
  14.     fmt.Println("kind:", v.Kind())
  15.     fmt.Println("value:", v.Float())
  16.     fmt.Println(v.Interface())
  17.     fmt.Printf("value is %5.2e\n", v.Interface())
  18.     y := v.Interface().(float64)
  19.     fmt.Println(y)
  20. }
  22. /**
  23. type: float64
  24. value: 3.4
  25. type: float64
  26. kind: float64
  27. value: 3.4
  28. 3.4
  29. value is 3.40e+00
  30. 3.4
  31. **/

2 通过反射修改(设置)值

可以使用 CanSet() 方法测试是否可设置
要想让其可设置我们需要使用 Elem() 函数，这间接的使用指针：v = v.Elem()

  1. package main
  3. import (
  4.     "fmt"
  5.     "reflect"
  6. )
  8. func main() {
  9.     var x float64 = 3.14
  10.     v := reflect.ValueOf(x)
  11.     //setting a value
  12.     //v.SetFloat(3.1415) // Error: will panic: reflect.Value.SetFloat using unaddressable value
  13.     fmt.Println("settability of v:", v.CanSet())
  14.     v = reflect.ValueOf(&x)
  15.     fmt.Println("type of v", v.Type())
  16.     fmt.Println("settability of v:", v.CanSet())
  17.     v = v.Elem()
  18.     fmt.Println("the elem of v is:", v)
  19.     fmt.Println("settability of v:", v.CanSet())
  20.     v.SetFloat(3.1415)
  21.     fmt.Println(v.Interface())
  22.     fmt.Println(v)
  23. }
  24. /**
  25. settability of v: false
  26. type of v *float64
  27. settability of v: false
  28. the elem of v is: 3.14
  29. settability of v: true
  30. 3.1415
  31. 3.1415
  33. **/

3.反射结构

有些时候需要反射一个结构类型。NumField() 方法返回结构内的字段数量；通过一个 for 循环用索引取得每个字段的值 Field(i)。
我们同样能够调用签名在结构上的方法，例如，使用索引 n 来调用：Method(n).Call(nil)。

  1. package main
  3. import (
  4.     "fmt"
  5.     "reflect"
  6. )
  8. type NotknownType struct {
  9.     s1, s2, s3 string
  10. }
  12. func (n NotknownType) String() string {
  13.     return n.s1 + " - " + n.s2 + " - " + n.s3
  14. }
  16. var secret interface{} = NotknownType{"ada", "go", "object"}
  18. func main() {
  19.     value := reflect.ValueOf(secret)
  20.     typ := reflect.TypeOf(secret)
  21.     //alternative
  22.     //typ := value.Type()
  23.     fmt.Println(value)
  24.     fmt.Println(typ)
  25.     knd := value.Kind()
  26.     fmt.Println(knd)
  28.     //iterate through the fields of struct
  29.     for i := 0; i < value.NumField(); i++ {
  30.         fmt.Printf("Field %d: %v\n", i, value.Field(i))
  31.         //value.Field(i).SetString("C#") //error: panic: reflect.Value.SetString using value obtained using unexported field
  32.     }
  34.     //call the first method, which is String():
  35.     results := value.Method(0).Call(nil)
  36.     fmt.Println(results)
  38. }

但是如果尝试更改一个值，会得到一个错误，因为结构中只有被导出字段（首字母大写）才是可设置的

  1. package main
  3. import (
  4.     "fmt"
  5.     "reflect"
  6. )
  8. type T struct {
  9.     A int
  10.     B string
  11. }
  13. func main() {
  14.     t := T{23, "skidoo"}
  15.     s := reflect.ValueOf(&t).Elem()
  16.     typeOfT := s.Type()
  17.     for i := 0; i < s.NumField(); i++ {
  18.         f := s.Field(i)
  19.         fmt.Printf("%d: %s %s = %v\n", i,
  20.             typeOfT.Field(i).Name, f.Type(), f.Interface())
  21.     }
  22.     s.Field(0).SetInt(77)
  23.     s.Field(1).SetString("test")
  24.     fmt.Println("t is now", t)
  25. }
  26. /**
  27. 0: A int = 23
  28. 1: B string = skidoo
  29. t is now {77 test}
  30. **/

4.printf和反射

fmt 包中的 Printf（以及其他格式化输出函数）都会使用反射来分析它的 … 参数。

  1. package main
  3. import (
  4.     "os"
  5.     "strconv"
  6. )
  8. type Stringer interface {
  9.     String() string
  10. }
  12. type Celsius float64
  14. func (c Celsius) String() string {
  15.     return strconv.FormatFloat(float64(c), 'f', 1, 64) + " ℃"
  16. }
  18. type Day int
  20. var dayName = []string{"Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"}
  22. func (day Day) String() string {
  23.     return dayName[day]
  24. }
  26. func print(args ...interface{}) {
  27.     for i, args := range args {
  28.         if i > 0 {
  29.             os.Stdout.WriteString(" ")
  30.         }
  31.         switch a := args.(type) {
  32.         case Stringer:
  33.             os.Stdout.WriteString(a.String())
  34.         case int:
  35.             os.Stdout.WriteString(strconv.Itoa(a))
  36.         case string:
  37.             os.Stdout.WriteString(a)
  38.         default:
  39.             os.Stdout.WriteString("???")
  40.         }
  41.     }
  42. }
  44. func main() {
  45.     print(Day(1), "was", Celsius(18.36))
  46. }