Golang réfléchit

Bienvenue dans un autre tutoriel de Golang. Nous apprendrons la réflexion dans le langage de programmation Go dans celui-ci.

Qu'est-ce que la réflexion?

La réflexion fait référence à la méthode d'analyse et d'inspection des variables et de leurs valeurs pendant l'exécution. C'est une technique très utile lorsqu'il s'agit de composants abstraits d'une structure. Cela ne signifie pas qu'il se limite aux structures. Discutons de diverses composantes de la réflexion à Golang.

Importations requises

En Go, la possibilité d'effectuer une réflexion est fournie en utilisant le package de réflexion. Par conséquent, nous devons l'importer avant utilisation. Vous pouvez l'importer comme indiqué dans l'extrait ci-dessous:

importer "refléter"

Une fois importé, vous pouvez commencer à utiliser les méthodes et fonctionnalités fournies.

Type de()

Une méthode du package de réflect est le typeof (). Cette fonction vous permet de déterminer le type de variable.

Pour l'utiliser, nous pouvons faire:

package principal
importer (
"FMT"
"refléter"
)
func main ()
var1: = 100
var2: = 3.14159
var3: = "Bonjour"
var4: = […] int 1, 2, 3
var5: = map [String] String
var6: = true
var7: = [] int 1, 2, 4
fmt.Println ("type =>", réfléchissez.Typeof (var1))
fmt.Println ("type =>", réfléchissez.Typeof (var2))
fmt.Println ("type =>", réfléchissez.Typeof (var3))
fmt.Println ("type =>", réfléchissez.Typeof (var4))
fmt.Println ("type =>", réfléchissez.Typeof (var5))
fmt.Println ("type =>", réfléchissez.Typeof (var6))
fmt.Println ("type =>", réfléchissez.Typeof (var7))

L'exemple ci-dessus utilise refléter.Typeof () Méthode pour vérifier les types de données de diverses variables. La sortie résultante est comme indiqué:

Type => int
Type => float64
Type => chaîne
Type => [3] int
Type => map [chaîne] chaîne
Type => bool
Type => [] int

Valeur de()

La réflexion.Valeurof () La méthode renvoie la valeur d'une variable spécifique. Un exemple est comme indiqué:

fmt.Println ("value =>", refléter.Valeur de (var4))

Cela devrait renvoyer la valeur de la variable var4.

Sortir:

Valeur => [1 2 3]

Copie()

La méthode de copie est utilisée pour copier les éléments d'une source spécifique vers une destination spécifiée. La fonction effectuera l'opération de copie jusqu'à ce que la destination soit pleine des éléments de la source est épuisé.

La fonction renvoie le nombre d'éléments copiés de la source à la destination.

N'oubliez pas que la destination et la source doivent être du même type.

Considérez l'exemple ci-dessous:

package principal
importer (
"FMT"
"refléter"
)
func main ()
src: = refléter.Value Of ([] String "A", "B", "C")
dest: = refléter.Value Of ([] String "D", "E", "F")
items_copied: = refléter.Copie (SRC, dest)
fmt.Println ("Éléments copiés:", items_copied)
fmt.Println ("source:", src)
fmt.Println ("Destination:", dest)

Dans l'exemple ci-dessus, nous utilisons la réflexion.Valeurof () pour lancer la variable à son type. Nous utilisons ensuite la méthode COPY () pour copier les éléments du DEST à la variable SRC. La sortie résultante est comme indiqué:

Éléments copiés: 3
Source: [d e f]
Destination: [d e f]

Swapper ()

La méthode Swapper () vous permet d'échanger des éléments dans une tranche. Un exemple est comme indiqué ci-dessous:

lst: = [] int 1, 2, 3, 4, 5
lst_swp: = refléter.Swapper (LST)
fmt.Printf ("avant l'échange:% v \ n", lst)
LST_SWP (0, 4)
fmt.Printf ("après swap:% v \ n", lst)

L'exemple ci-dessus échange la tranche du premier index au dernier. La sortie est comme indiqué:

Avant l'échange: [1 2 3 4 5]
Après l'échange: [5 2 3 4 1]

Numfield ()

La méthode numfield () renvoie le nombre de champs dans une structure donnée. Un exemple est comme indiqué:

Tapez my_struct struct
Field_1 String
field_2 int
field_3 float64
field_4 bool

struct_1: = my_struct "a", 1, 3.14, faux
casting: = refléter.Typeof (struct_1)
fmt.Println (casting.Numfield ())

Ce qui précède doit renvoyer le nombre de champs dans la structure. Sortir:

4

Champ()

La méthode champ () renvoie le nom et le type de données des champs dans une structure.

struct_1: = my_struct "a", 1, 3.14, faux
casting: = refléter.Typeof (struct_1)
pour i: = 0; je < cast.NumField(); i++
Champ: = Cast.Champ (i)
fmt.Println (champ.Nom, champ.Taper)

Le programme ci-dessus renvoie le nom des champs dans la structure et leurs types de données. Sortir:

Field_1 String
field_2 int
field_3 float64
field_4 bool

Makechan ()

La méthode makechan () crée un canal de type spécifié et le canal de taille de tampons. Exemple:

Var Str Chan String
var str_type reflète.Valeur = réfléchir.Valeur de (& str)
new_channel: = refléter.Makechan (réfléchir.Indirect (str_type).Type (), 256)
fmt.Println ("canal kind:", new_channel.Type())
fmt.Println ("CAP CAP:", new_channel.Casquette())

Ce qui précède doit créer un canal de type chan et une taille de tampon de 256. La sortie résultante est comme indiqué:

Kind Kind: Chan
Capeur de canal: 256

MakeMap ()

Comme son nom l'indique, la fonction makeMap () crée une carte du type de données défini.

Prenez l'exemple ci-dessous:

String Var Str Map [String]
var str_type reflète.Valeur = réfléchir.Valeur de (& str)
my_map: = refléter.Makemap (réfléchir.Indirect (str_type).Taper())
fmt.Println ("kind =>", my_map.Type())

Cela crée une nouvelle carte. Sortir:

Kind => map

Conclusion

Dans ce guide, nous avons rayé la surface de l'utilisation du package de réflexion dans Go. Gardez à l'esprit que le package offre bien plus que ce qui est discuté ici.