1 简介

反射是指在程序运行期对程序本身进行访问和修改的能力
变量包含类型信息和值信息

  • 类型信息：是静态的元信息，是预先定义好的
  • 值信息：是程序运行过程中动态改变的

reflect包封装了反射相关的方法

  • 获取类型信息：reflect.TypeOf，是静态的
  • 获取值信息：reflect.ValueOf，是动态的

    2 TypeOf, ValueOf

    ```go package main

import ( “fmt” “reflect” )

// 定义结构体 type User struct { Id int Name string Age int }

// 绑方法 func (u User) Hello() { fmt.Println(“Hello”) }

// 传入interface{} func Poni(o interface{}) { // 获取类型 t := reflect.TypeOf(o) fmt.Println(“类型：”, t) // main.User fmt.Println(“字符串类型：”, t.Name()) // User // 获取种类 k := t.Kind() fmt.Println(“种类:”, k) // struct // 获取值 v := reflect.ValueOf(o) fmt.Println(v) // {1 zs 20}

  1. // 获取结构体字段个数：t.NumField()
  2. for i := 0; i < t.NumField(); i++ {
  3.     // 取每个字段
  4.     f := t.Field(i)
  5.     fmt.Printf("%s : %v", f.Name, f.Type) // Id : int
  6.     // 获取字段的值信息
  7.     // Interface()：获取字段对应的值
  8.     val := v.Field(i).Interface()
  9.     fmt.Println("val :", val) // val : 1
  10. }
  12. // 获取结构体方法个数：t.NumMethod()
  13. for i := 0; i < t.NumMethod(); i++ {
  14.     m := t.Method(i)
  15.     fmt.Println(m.Name) // Hello
  16.     fmt.Println(m.Type) // func(main.User)
  17. }

}

func main() { u := User{1, “zs”, 20} Poni(u) }

  1. <a name="pTbgQ"></a>
  2. # 3 DeepEqual
  3. ```go
  4. package main
  6. import (
  7.     "fmt"
  8.     "reflect"
  9. )
  11. func main() {
  12.     s1 := []int{1, 2, 3}
  13.     s2 := []int{1, 2, 3}
  14.     s3 := []int{2, 3, 1}
  15.     fmt.Println(reflect.DeepEqual(s1, s2), reflect.DeepEqual(s1, s3)) // true false
  16. }
  1. package main
  3. import (
  4.     "errors"
  5.     "fmt"
  6.     "reflect"
  7. )
  9. type Employee struct {
  10.     Name string
  11.     Age  int
  12. }
  14. type Customer struct {
  15.     Name string
  16.     Age  int
  17. }
  19. func fillBySettings(st interface{}, settings map[string]interface{}) error {
  20.     if settings == nil {
  21.         return errors.New("settings is nil")
  22.     }
  23.     if reflect.TypeOf(st).Kind() != reflect.Ptr {
  24.         return errors.New("第一参数应是 指针")
  25.     }
  26.     if reflect.TypeOf(st).Elem().Kind() != reflect.Struct { // Elem()获取指针 指向的值
  27.         return errors.New("第一参数应是 结构体指针")
  28.     }
  29.     var (
  30.         field reflect.StructField
  31.         ok    bool
  32.     )
  33.     for k, v := range settings {
  34.         if field, ok = (reflect.ValueOf(st)).Elem().Type().FieldByName(k); !ok {
  35.             continue
  36.         }
  37.         if field.Type == reflect.TypeOf(v) {
  38.             vstr := reflect.ValueOf(st)
  39.             vstr = vstr.Elem()
  40.             vstr.FieldByName(k).Set(reflect.ValueOf(v))
  41.         }
  42.     }
  43.     return nil
  44. }
  46. func main() {
  47.     settings := map[string]interface{}{"Name": "Mike", "Age": 40}
  48.     e := &Employee{}
  49.     _ = fillBySettings(e, settings)
  50.     fmt.Println(e)
  52.     c := new(Customer)
  53.     _ = fillBySettings(c, settings)
  54.     fmt.Println(c)
  56.     fmt.Println(reflect.DeepEqual(e, c)) // false
  57. }