Ein Artikel vermittelt Ihnen die Grundlagen der Reflexion in der Go-Sprache

Was ist Reflexion? Reflexion, ähm..., es bedeutet Umkehrung, also Dinge umdrehen.

Zum Beispiel ein sehr einfacher Code wie dieser.

var a int = 3
fmt.Println(a)

Natürlich wissen wir es

a

Die Variable ist int code><code style="font-family: var(--monospace);vertical-align: initial;border-width: 1px;border-style: solid;border-color: rgb(231, 234, 237);background-color: rgb(243, 244, 244);border-radius: 3px;padding-right: 2px;padding-left: 2px;font-size: 0.9em;">a变量是int类型，但是反过来想，程序是怎么知道a是int Typ, aber denken Sie andersherum, woher weiß das Programm a

is

int

? ? ?

Zu diesem Zeitpunkt müssen Sie Reflexion verwenden.

Beispielcode

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

🎜Zwei Codes werden zu einem Ausführungsergebnis kombiniert🎜🎜🎜🎜🎜🎜

Die zweite Codezeile hat die Variable zum zweiten Mal erfolgreich geändert aa还原出了int类型。

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

反射(reflect包)

在Go中，任何变量，都有具体类型和具体值，就像var a int = 3，具体类型就是int，具体值就是3restauriertint

🎜 Typ. 🎜
🎜

🎜In Go hat jede Variable einen 🎜spezifischen Typ strong>🎜🎜 und 🎜Spezifischer Wert🎜🎜, wie 🎜🎜var a int = 3🎜🎜, 🎜Spezifischer Typ 🎜🎜 ist 🎜🎜int🎜🎜, 🎜Spezifischer Wert🎜🎜 ist 🎜🎜3🎜🎜. 🎜🎜

Der spezifische Typ der Variablen gehört also zu reflect.Typereflect.Type，变量的具体值归属在reflect.Value。

并且Go的提供了

• reflect.TypeOf获取具体类型。

• reflect.ValueOf获取具体值。

TypeOf

TypeOf, der spezifische Wert der Variablen gehört zu reflect.Value

.

🎜reflect.TypeOf🎜🎜Holen Sie sich den 🎜🎜🎜spezifischen Typ🎜🎜🎜. 🎜🎜

🎜reflect.ValueOf🎜🎜get🎜 🎜🎜Spezifischer Wert🎜🎜🎜. 🎜🎜

🎜TypeOf🎜

🎜 Die TypeOf🎜🎜-Methode kann den 🎜🎜🎜spezifischen Typ🎜🎜🎜 einer Variablen abrufen. 🎜🎜🎜🎜Es besteht die Notwendigkeit, eine Funktion zu definieren, die jeden Datentyp empfangen und den Variablentyp durch Reflexion drucken kann. 🎜🎜

示例代码

函数

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。

Wenn die Variable ein Referenztyp (Slice und Map)-Typ ist, NameName为空，只有Kind。

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

ValueOf

TypeOf ist leer, nur Art.

Wenn die Variable eine

Struktur ist ,

Name🎜🎜 ist Strukturname, 🎜🎜Kind🎜🎜 Ja 🎜🎜struct🎜🎜. 🎜🎜

🎜ValueOf🎜

🎜TypeOfnur 🎜🎜 Sie können wiederum den 🎜🎜🎜spezifischen Typ🎜🎜🎜 der Variablen erhalten, aber Sie können nicht den 🎜🎜🎜spezifischen Wert🎜🎜🎜 erhalten, was etwas unfreundlich ist. 🎜🎜

所以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)
}

执行结果

总结

上述我们学习了Go基础反射的TypeOfTypeOf，TypeOf的Name和Kind，ValueOf，通过反射设置值。

其中Kind在Type和ValueOf中都有，通常情况下TypeOf和ValueOf，TypeOf的Name和Kind

，ValueOf

🎜，🎜🎜通过反射设置值🎜🎜。🎜🎜

Kind🎜🎜在🎜🎜<code style="font-family: var(--monospace);vertical-align: initial;border-width: 1px;border-style: solid;border-color: rgb(231, 234, 237);background -color: rgb(243, 244, 244);border-radius: 3px;padding-right: 2px;padding-left: 2px;font-size: 0.9em;">Type🎜🎜和🎜🎜ValueOf🎜🎜中都有，通常情况下🎜🎜TypeOf🎜🎜和🎜🎜ValueOf🎜🎜一起使用效果更佳！🎜 🎜🎜🎜反射这一块！坚持！！🎜🎜

Das obige ist der detaillierte Inhalt vonEin Artikel vermittelt Ihnen die Grundlagen der Reflexion in der Go-Sprache. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!