UTILISER Reflect.TypeOf () et Reflect.ValueOf () pour obtenir le type et la valeur de la variable, où la valeur de renvoie une copie; 2. Vous pouvez traverser les champs de structure par la réflexion pour obtenir le nom du champ, le type et l'étiquette des informations; 3. Pour modifier la valeur, vous devez passer un pointeur et appeler elem () pour obtenir la valeur adressable, et vous devez vérifier CanSet (); 4. Vous pouvez traverser les champs de structure et définir une nouvelle valeur en fonction du type; 5. Obtenez la méthode via MethodByName () et appelez-la avec Call (); 6. Vous pouvez déterminer si le type implémente une méthode ou une interface spécifique; Les performances de réflexion sont faibles, vous devez donc éviter d'utiliser un chemin chaud. Lors de la modification de la valeur, vous devez passer un pointeur. Le champ qui n'a pas été exporté ne peut être modifié. Le jugement de type est préféré utiliser kind (). Ce mécanisme est très pratique dans la sérialisation JSON, l'ORM et l'analyse de configuration.

Dans GO, la réflexion est un mécanisme puissant qui permet aux programmes de vérifier les types et les valeurs des variables au moment de l'exécution, et même les modifier. Le package reflect de Go fournit les fonctions principales pour implémenter la réflexion. Voici quelques exemples courants pour illustrer comment utiliser la réflexion de Go.

1. Réflexion des types et valeurs de base

Utiliser reflect.TypeOf() et reflect.ValueOf() pour obtenir le type et la valeur d'une variable.

 package principal

importer (
    "FMT"
    "refléter"
)

func main () {
    var x int = 42

    T: = reflev
    fmt.println ("valeur:", v) // 42
    fmt.println ("kind:", v.kind ()) // int
}

Remarque: reflect.ValueOf(x) renvoie une copie de x , pas une référence.

2. Obtenez des informations sur le terrain de structure

La réflexion est souvent utilisée pour traiter les structures, telles que l'obtention de noms de champ, de types, d'étiquettes, etc.

 Tapez user struct {
    Nom String `JSON:" Name "`
    ?ge Int `JSON:" Age "`
}

func main () {
    Var U utilisateur
    t: = reflev.ypeof (u)

    pour i: = 0; i <t.numfield (); je {
        Champ: = T.field (i)
        fmt.printf ("Nom de champ:% S, Type:% S, tag json:% s \ n",
            field.name, field.type, field.tag.get ("json"))
    }
}

Sortir:

 Nom du champ: nom, type: cha?ne, tag json: nom
Nom du champ: Age, Type: INT, JSON TAG: ?ge

3. Modifier la valeur de la variable (besoin de passer dans le pointeur)

Si vous souhaitez modifier la valeur par la réflexion, vous devez passer dans un pointeur, sinon ce sera la panique.

 func main () {
    var x int = 10
    v: = reflents.valueof (& x) // passer dans le pointeur elem: = v.elem () // Obtenez la valeur pointée par le pointeur si elem.canset () {
        elem.sentInt (20)
    }

    Fmt.println (x) // Sortie: 20
}

elem.CanSet() détermine si la valeur peut être modifiée (par exemple, les champs qui ne sont pas exportés ne peuvent pas être définis).

4. Champs de structure de traversée et de définition

 Type personne struct {
    Cha?ne de noms
    ?ge int
}

func main () {
    p: = personne {nom: "Alice", age: 0}
    v: = réflect.valueof (& p) .elem () // Obtenez la valeur modifiable pointée par le pointeur pour i: = 0; i <v.numfield (); je {
        champ: = V.field (i)
        if field.canset () && field.kind () == reflète.int {
            Field.SetInt (25)
        }
    }

    fmt.printf ("% v \ n", p) // {nom: Alice ?ge: 25}
}

5. Méthode d'appel (par réflexion)

 type greeter struct {}

func (g greeter) sayhello (name String) {
    fmt.println ("bonjour", nom)
}

func main () {
    g: = greeter {}
    v: = reflect.valueof (g)

    // Obtenir la méthode Méthode: = V.MethodByName ("Sayhello")
    si méthode.isvalid () {
        args: = [] reflev.value {Reflect.valueof ("bob")}
        Method.Call (Args) // Sortie: Bonjour, Bob
    }
}

6. Déterminez si le type implémente une interface

 Tapez l'interface du haut-parleur {
    String Speak ()
}

Type Dog Struct {}

func (d chien) dispose () String {return "woof!" }

func main () {
    d: = chien {}
    t: = reflev.ypeof (d)
    _, OK: = T.MethodByName ("Speak")
    fmt.println ("implémente la méthode Speak:", ok) // true

    // ou plus déterminer avec précision si l'interface est implémentée_, implémente: = reflète.typeof ((* haut-parleur) (nil)). Elem (). MethodByName ("Speak")
    fmt.println ("L'interface définit Speak:", implémente)
}

Résumé: opérations communes pour la réflexion

• reflect.TypeOf(v) → Get Type
• reflect.ValueOf(v) → Obtenir la valeur
• .Kind() → Types de base (tels que int , struct , slice , etc.)
• .Elem() → pointeur, valeur sous-jacente d'interface
• .Field(i) / .Method(i) → Obtenez un champ ou une méthode
• .SetXXX() → modifier la valeur (nécessite l'adressable)
• .Call() → Méthode d'appel

Choses à noter

• Les performances de réflexion sont faibles, alors essayez d'éviter de l'utiliser dans le chemin chaud.
• Lors de la modification des valeurs avec réflexion, un pointeur doit être transmis, sinon il ne peut pas être modifié.
• Notez si le champ peut être exporté (première lettre), sinon CanSet() est faux.
• Utilisez Kind() au lieu de Type() pour juger davantage le type, car Kind renvoie le type sous-jacent.

Fondamentalement, ces utilisations courantes. Bien que la réflexion de Go ne soit pas aussi flexible que les autres langues, elle est très pratique dans des scénarios tels que la sérialisation (comme JSON), l'ORM, l'analyse de configuration, etc.

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!