Un article vous apprend les bases de la réflexion en langage Go

Qu'est-ce que la réflexion

La réflexion, euh..., ça veut dire inverser, c'est-à-dire retourner les choses.

Par exemple, un code très simple comme celui-ci.

var a int = 3
fmt.Println(a)

Bien sûr que nous le savons a a变量是int类型，但是反过来想，程序是怎么知道a是intLa variable est int code><br>

tapez, mais réfléchissez-y dans l'autre sens, comment le programme sait-il

a

est

int

 ? ? ?

En ce moment, vous devez utiliser la réflexion.

Exemple de code

🎜🎜

v := reflect.TypeOf(a)
fmt.Println(v)

🎜🎜🎜Deux codes sont combinés en un seul résultat d'exécution🎜🎜🎜🎜🎜🎜

La deuxième ligne de code a modifié avec succès la variable aa还原出了int类型。

什么？？？你为我有什么用？？？，嗯。。。实话实说，用的不是太多，但是必须要会的。

反射(reflect包)

在Go中，任何变量，都有具体类型和具体值，就像var a int = 3，具体类型就是int，具体值就是3restauréType spécifique 🎜🎜 est 🎜🎜int🎜🎜, 🎜La valeur spécifique🎜🎜 est 🎜🎜3🎜🎜. 🎜🎜

Donc, le type spécifique de la variable appartient à reflect.Typereflect.Type，变量的具体值归属在reflect.Value。

并且Go的提供了

• reflect.TypeOf获取具体类型。

• reflect.ValueOf获取具体值。

TypeOf

TypeOf, la valeur spécifique de la variable appartient à reflect.Value

.

And Go fournit 🎜🎜

• 🎜reflect.TypeOf🎜🎜Obtenez le 🎜🎜🎜type spécifique🎜🎜🎜. 🎜🎜

• 🎜示例代码

  函数

  func reflectType(x interface{}) {
      v := reflect.TypeOf(x)
      fmt.Printf("你传入的变量类型是:%v\n"，v)
  }

  main
  

  func main() {
      var a int = 666
      var b float64 = 3.14
      var c string = "hello world"
      var d [3]int = [3]int{1，2，6}
      var e []int = []int{1，2，6，88}
      var f map[string]interface{} = map[string]interface{}{
          "Name":"张三"，
          "Age":18，
  }
      reflectType(a)
      reflectType(b)
      reflectType(c)
      reflectType(d)
      reflectType(e)
      reflectType(f)
  }

  执行结果
  

  

  通过reflect.TypeOf方法，完美解决上述需求。
  

  TypeOf 的Name和Kind

  这个是啥意思呢??这个在结构体中比较好体现。

  简答来说就是TypeOf返回的太笼统了，还有更加细化的类型，通过这俩属性获取。

  示例代码

  函数

  func reflectType(x interface{}) {
  v := reflect.TypeOf(x)
  fmt.Printf("你传入的变量类型是:%v | Name:%v | Kind:%v\n"， v， v.Name()， v.Kind())
  }

  结构体
  

  type Student struct {
      Name string
      Age int
  }

  main
  

  func main() {
      var a int
      var b *int
      var c []int
      var d map[string]interface{}
      var e Student
      reflectType(a)
      reflectType(b)
      reflectType(c)
      reflectType(d)
      reflectType(e)
  }

  执行结果
  

  

  总结
  

  经过对比，会发现几个特殊问题。

  如果变量是指针类型，Name为空，Kind是ptr。

  Si la variable est un type type de référence (tranche et carte), NomName为空，只有Kind。

  如果变量是结构体，Name是结构体名，Kind是struct。

  ValueOf

  TypeOf est vide, seulement Type.

  Si la variable est une structure ,

  Nom🎜🎜 est le nom de la structure, 🎜🎜🎜ValueOf🎜<p cid="n56" mdtype="paragraph" style="line-height: hériter; orphelins : 4; marge-haut : 0,8em; marge- bas : 0,8 em ; espace blanc : pré-enveloppement ; famille de polices : " open sans neue helvetica arial sans-serif taille de police du texte start>🎜<code style="font-family: var(--monospace);vertical-align: initial;border-width: 1px;border-style: solid;border-color: rgb(231, 234, 237 );couleur d'arrière-plan : rgb(243, 244, 244);rayon de bordure : 3 px;padding-right : 2px;padding-left : 2px;taille de police : 0,9em;">TypeOf🎜🎜uniquement Vous pouvez obtenir le 🎜🎜🎜type spécifique🎜🎜🎜 de la variable à votre tour, mais vous ne pouvez pas obtenir la 🎜🎜🎜valeur spécifique🎜🎜🎜, ce qui est un peu méchant. 🎜🎜

  所以ValueOf就来解决这个问题了，但是ValueOf牛叉的是，它里面还包括了变量类型。

  注:ValueOf和TypeOf的Kind属性返回内容是一摸一样的。

  需求:定义一个函数，可以接收任意类型，通过反射得出变量类型和变量值。

  函数

  func reflectType(x interface{}) {
      v := reflect.ValueOf(x)
      k := v.Kind()
      switch k {
      case reflect.Int:
          fmt.Printf("我是Int类型，我的值是%v\n"，v.Int())
      case reflect.Slice:
          fmt.Printf("我是切片类型，我的值是%v\n"，v.Slice(1，2))
      case reflect.Map:
          fmt.Printf("我是切片类型，我的值是%v\n"，v.MapKeys())
      //case :可以继续case下去
    }
  }

  main
  

  func main() {
    var a int = 1
    var c []int = []int{1， 5， 7， 19}
    var d map[string]interface{} = map[string]interface{}{
      "Name": "你好"，
      "Age":  18，
    }
    var e Student
    reflectType(a)
  
  
    reflectType(c)
    reflectType(d)
    reflectType(e)
  }

  执行结果
  

  

  通过反射设置值
  

  反射还有一个用途，就是动态的修改变量值，可能你暂时体会不到，但是语法还是要学的。

  通过反射设置值，需要用到Elem方法，并且传入的必须是指针。

  示例代码

  函数

  func reflectSetValue(x interface{}) {
    v := reflect.ValueOf(x)
    //kind也必须是Elem调用
    var k = v.Elem().Kind()
    switch k {
    case reflect.Int:
      //反射修改必须通过Elem
      v.Elem().SetInt(200)
    }
  }

  main
  

  func main() {
    var a int = 10
    fmt.Printf("a的值:%v\n"， a)
    //反射修改值传入的必须是地址
    reflectSetValue(&a)
    fmt.Printf("a的值:%v\n"， a)
  }

  执行结果
  

  

  TypeOf

  ，
  TypeOf的Name和Kind

  ，ValueOfTypeOf，TypeOf的Name和Kind，ValueOf，通过反射设置值。

  其中Kind在Type和ValueOf中都有，通常情况下TypeOf和ValueOf，通过反射设置值

  。
  其中
  🎜Kind🎜🎜在🎜🎜ValueOf🎜🎜一起使用效果更佳！🎜 🎜🎜🎜反射这一块，可能不是那么好理解，一定要多多下功夫！坚持！！🎜🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!