Aller refléter le package expliqué

Le package de réflect de Go permet le fonctionnement dynamique des variables au moment de l'exécution, le noyau étant refléter. Obtention d'informations de type via v: = réflect.valueof (myvar) et t: = v.type (). Le fonctionnement des champs de structure et des étiquettes doit être traversé et vérifié. La modification des valeurs nécessite d'assurer une adresse et des méthodes d'appel telles que .Elem () et .sentInt (). Lorsque vous l'utilisez, vous devez prêter attention aux pertes de performances et éviter les scénarios inutiles.

Si vous avez déjà examiné le système de réflexion de Go ou que vous avez essayé de construire quelque chose de dynamique dans GO, vous connaissez probablement le package reflect . C'est puissant mais peut se sentir un peu cryptique si vous êtes nouveau. L'idée principale est que GO vous permet d'inspecter et de manipuler des variables lors de l'exécution, même lorsque leurs types ne sont pas connus à l'avance.

Voici ce que vous devez savoir pour commencer à utiliser efficacement Reflect sans vous perdre.

Compréhension reflète.

Au cœur du package reflect se trouvent deux composantes principales: Type et Value .

• reflect.Type vous indique de ce que le type a une variable (comme int , string ou une structure personnalisée).
• reflect.Value vous donne accès aux données réelles stockées à l'intérieur de la variable.

Pour les obtenir, vous faites généralement quelque chose comme:

 v: = reflev.Valueof (myvar)
t: = v.type ()

Vous pouvez ensuite creuser dans des choses comme:

• Noms et types de champs dans une structure
• Signatures méthode
• Si une valeur est un pointeur ou une tranche

Une chose à surveiller: si vous passez un pointeur dans reflect.ValueOf , par défaut vous obtiendrez un reflect.Value représentant le pointeur lui-même, pas à quoi il pointe. Vous devrez peut-être appeler .Elem() pour obtenir la valeur sous-jacente.

Modification des valeurs avec réflexion

Oui, vous pouvez modifier les valeurs dynamiquement en utilisant reflect . Mais il y a une prise - la valeur doit être adressable . Cela signifie généralement que vous devez passer un pointeur pour reflect.ValueOf .

Par exemple:

 x: = 10
v: = reflev.valueof (& x) .elem () // Obtenez la valeur réelle derrière le pointeur
si v.canset () {
    v.setInt (20) // maintenant x devient 20
}

Une erreur courante consiste à essayer de modifier une valeur inaccessible et à vous gratter la tête pourquoi cela ne fonctionne pas. Vérifiez donc toujours si une valeur est établie avec .CanSet() avant d'essayer de la modifier.

Notez également que GO applique la sécurité de type ici. Si vous essayez d'attribuer un mauvais type - comme définir une chaîne dans un champ int - cela paniquera.

Travailler avec des structures en utilisant la réflexion

La réflexion brille vraiment lorsque vous travaillez avec des structures. Disons que vous avez une structure comme ceci:

 Tapez user struct {
    Chaîne de noms
    Âge Int `JSON:" Age "`
}

Avec réflexion, vous pouvez:

• Boucle à travers les champs en utilisant .NumField() et .Field(i)
• Accédez aux étiquettes de champ via .Tag.Get("json")
• Obtenir ou définir des valeurs de champ individuelles dynamiquement

Ceci est super utile dans des scénarios comme:

• Construire des cartographies JSON génériques génériques
• Valider automatiquement les champs de structure
• Générer des requêtes de base de données basées sur des champs de structure

N'oubliez pas d'utiliser les vérifications de type correctes ( v.Kind() == reflect.Struct ) et de gérer attentivement les structures imbriquées.

Éviter les pièges communs

La réflexion dans GO est flexible, mais elle est livrée avec des gotchas:

• Performances : le code basé sur la réflexion est plus lent que l'accès direct. Utilisez-le uniquement lorsque cela est nécessaire.
• Paniques : Beaucoup reflètent les opérations paniquent au lieu de retourner des erreurs - enveloppez toujours les appels dans recover() si nécessaire.
• Emballage de l'interface : sachez que reflect.Value.Interface() renvoie une interface vide, de sorte que des affirmations de type sont nécessaires par la suite.

Gardez également à l'esprit que la réflexion a tendance à rendre le code plus difficile à lire et à maintenir. S'il existe un moyen d'éviter de l'utiliser - en particulier dans les API publiques - il vaut généralement mieux suivre cette voie.

C'est essentiellement la façon dont vous commencez à travailler avec le package de réflexion de Go. Ce n'est pas trop compliqué une fois que vous avez obtenu le type de type et de valeur, mais cela nécessite une manipulation minutieuse.

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!