Comprenez les trois lois de la réflexion du langage Go et débloquez un nouveau domaine de programmation

Trois lois de la réflexion du langage Go : Séparation des types et des valeurs : les types décrivent les structures de données et les valeurs représentent des instances spécifiques. Les valeurs des données peuvent être manipulées : la réflexion permet d'accéder et de modifier les valeurs, d'implémenter des structures de données dynamiques et d'autres fonctions. Utilisé via le package Reflection : les opérations de réflexion sont implémentées via le package Reflect, qui fournit des outils pour inspecter et manipuler les valeurs, les types et les interfaces.

Comprendre les trois lois de la réflexion en langage Go

En langage Go, la réflexion permet au programme d'inspecter et d'exploiter sa propre structure de données au moment de l'exécution. En comprenant et en appliquant les trois lois, vous pouvez profiter pleinement du pouvoir de la réflexion et réaliser une programmation flexible et dynamique.

Loi 1 : Les types et les valeurs ne sont pas la même chose

Les types décrivent la structure des données, tandis que les valeurs représentent des instances spécifiques de données. La réflexion vous permet d'obtenir des informations de type sur une valeur sans connaître au préalable son type spécifique.

Exemple de code :

type Person struct {
    Name string
    Age  int
}

func main() {
    p := Person{Name: "John", Age: 30}
    t := reflect.TypeOf(p) // 获得值类型
    fmt.Println(t) // 输出: main.Person
}

Loi 2 : Les valeurs peuvent être manipulées

La réflexion ne se limite pas à obtenir des informations de type, elle vous permet également d'accéder et de modifier la valeur elle-même. Cela signifie que vous pouvez utiliser la réflexion pour implémenter des structures de données dynamiques, des sérialiseurs personnalisés, etc.

Exemple de code :

type Person struct {
    Name string
    Age  int
}

func main() {
    p := Person{Name: "John", Age: 30}
    v := reflect.ValueOf(p) // 获得值
    v.FieldByName("Age").SetInt(31) // 修改值
    fmt.Println(p) // 输出: {John 31}
}

Loi 3 : Utiliser le package Reflect

Toutes les opérations de réflexion sont implémentées via le package reflect. Ce package fournit un ensemble de types et de fonctions qui vous permettent d'inspecter et de manipuler des valeurs, des types et des interfaces.

Cas pratique :

Imaginez que vous ayez une liste de données structurées inconnues provenant d'une base de données. Vous pouvez utiliser la réflexion pour parcourir la liste et obtenir dynamiquement le type et les données de chaque valeur :

type Person struct {
    Name string
    Age  int
}

type Address struct {
    Street  string
    City    string
    Country string
}

func main() {
    data := []interface{}{
        Person{Name: "John", Age: 30},
        Address{Street: "Main St.", City: "Anytown", Country: "USA"},
    }

    for _, v := range data {
        t := reflect.TypeOf(v)
        fmt.Println("Type:", t.Name())

        v = reflect.ValueOf(v)
        for i := 0; i < v.NumField(); i++ {
            field := v.Field(i)
            fmt.Println("  Field:", t.Field(i).Name, " Value:", field.Interface())
        }
    }
}

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!