La réflexion dans Golang permet à un programme d'examiner et de modifier les structures de données, les types et les valeurs lors de l'exécution. Il fournit un ensemble de fonctions qui nous permettent d'examiner le type et la valeur de n'importe quelle variable au moment de l'exécution, de créer de nouvelles instances de types et de modifier la valeur des variables existantes. Cet article couvre différentes fonctions Golang dans le package reflect.
Table des matières
- Reflect Package en Go
- Fonction reflect.Copy()
- Fonction reflect.DeepEqual()
- Fonction reflect.Swapper()
- Fonction reflect.TypeOf()
- Fonction reflect.ValueOf()
- Conclusion
Go est un langage typé statiquement, le type d'une variable doit donc être connu au moment de la compilation. Cependant, dans certains scénarios, il peut être nécessaire de gérer des valeurs dont les types ne peuvent pas être déterminés tant que le programme n'est pas exécuté.
Par exemple, nous pouvons avoir besoin d'écrire une fonction qui peut fonctionner avec différents types d'arguments, ou nous pouvons avoir besoin de sérialiser et de désérialiser des données de types inconnus. C'est là que le package reflect est utilisé dans Golang.
Reflect Package en Go
Le package reflect fournit un ensemble de fonctions qui nous permettent d'inspecter et de manipuler des valeurs au moment de l'exécution, quel que soit leur type. Avec ces fonctions, nous pouvons obtenir des informations sur le type et la valeur de n'importe quelle variable, créer de nouvelles instances de types et modifier la valeur des variables existantes.
Le package reflect dans Golang contient deux types : Type et valeur. Un Type représente un type Go, tel que int, string ou une structure personnalisée. Une valeur représente une valeur d'un type spécifique, comme 42 ou 'hello'.
Le package reflect fournit également un ensemble de fonctions qui nous permettent d'obtenir des objets Type et Value à partir de variables. Par exemple, la fonction reflect.TypeOf() renvoie un objet Type qui représente le type d'une variable, tandis que la fonction reflect.ValueOf() renvoie un objet Value qui affiche la valeur de la variable.
Dans les sections suivantes, nous allons explorer certaines des fonctions couramment utilisées dans le package reflect.
Fonction reflect.Copy()
La fonction reflect.Copy() du package reflect est utilisée pour copier les valeurs d'une tranche dans une autre tranche. Il prend deux paramètres, dst et src, qui doivent tous deux être des valeurs de tranche avec le même type d'élément. La fonction copie les valeurs de la tranche src dans la tranche dst et renvoie le nombre d'éléments qui ont été copiés.
La fonction reflect.Copy() est illustrée dans l'exemple suivant :
emballer principalimporter (
'fmt'
'refléter'
)
fonction principal () {
src := [] entier { 1 , 2 , 3 , 4 , 5 }
heure d'été := faire ([] entier , seul ( src ))
n := refléter . Copie ( refléter . Valeur de ( heure d'été ), refléter . Valeur de ( src ))
fmt . Imprimerln ( n ) // Sortie : 5
fmt . Imprimerln ( heure d'été ) // Sortie : [1 2 3 4 5]
}
Dans cet exemple, nous créons une tranche source src avec des valeurs entières et une tranche de destination dst avec la même longueur que src. Nous appelons ensuite reflect.Copy() pour copier les valeurs de src vers dst et imprimer le nombre d'éléments qui ont été copiés (n) et le contenu de la tranche dst.
Fonction reflect.DeepEqual()
La fonction reflect.DeepEqual() du package reflect est utilisée pour comparer deux valeurs d'égalité. Cette fonction a deux paramètres d'entrée qui sont a et b, qui peuvent tous deux avoir n'importe quelle valeur de n'importe quel type. La fonction renvoie true si a et b sont profondément égaux, ce qui signifie que leurs valeurs sous-jacentes sont récursivement égales. Sinon, il s'avère être faux.
L'exemple suivant montre comment utiliser reflect.DeepEqual() :
emballer principalimporter (
'fmt'
'refléter'
)
fonction principal () {
un := [] entier { 1 , 2 , 3 }
b := [] entier { 1 , 2 , 3 }
si refléter . DeepEqual ( un , b ) {
fmt . Imprimerln ( 'a et b sont égaux' )
} autre {
fmt . Imprimerln ( 'a et b ne sont pas égaux' )
}
}
Dans cet exemple, nous créons deux tranches a et b avec les mêmes valeurs entières. Nous appelons ensuite reflect.DeepEqual() pour comparer a et b pour l'égalité et imprimer le résultat.
Fonction reflect.Swapper()
La fonction reflect.Swapper() du package reflect est utilisée pour renvoyer une fonction qui peut échanger les éléments d'une tranche. Il prend un seul paramètre, v, qui doit être une valeur de tranche. La fonction renvoie une fonction qui prend deux paramètres entiers, i et j, et permute les éléments de la tranche aux positions i et j.
L'utilisation de reflect.Swapper() peut être illustrée par l'exemple suivant :
emballer principalimporter (
'fmt'
'refléter'
)
fonction principal () {
s := [] entier { 1 , 2 , 3 , 4 , 5 }
échanger := refléter . Échangeur ( s )
échanger ( 1 , 3 )
fmt . Imprimerln ( s ) // Sortie : [1 4 3 2 5]
}
Dans cet exemple, nous avons créé une tranche nommée s avec des valeurs entières. Nous appelons ensuite reflect.Swapper() pour obtenir une fonction swap qui peut échanger des éléments de la tranche. Nous utilisons swap pour échanger les éléments aux positions 1 et 3 de la tranche s et imprimer le résultat.
Fonction reflect.TypeOf()
Le reflect.TypeOf() est utilisé pour obtenir le type d'une valeur. Cette fonction accepte un seul paramètre 'v' qui peut être de n'importe quel type ou valeur. La fonction renvoie une valeur reflect.Type qui représente le type de la valeur.
L'utilisation de reflect.TypeOf() peut être illustrée par l'exemple suivant :
emballer principalimporter (
'fmt'
'refléter'
)
fonction principal () {
était X float64 = 3 . 14
t := refléter . Type de ( X )
fmt . Imprimerln ( t ) // Sortie : float64
}
Dans cet exemple, nous créons une variable float64 x avec la valeur 3.14. Nous appelons ensuite reflect.TypeOf() pour obtenir le type de x et stockons le résultat dans une variable reflect.Type t. Nous imprimons la valeur de t, qui est float64.
Fonction reflect.ValueOf()
Le reflect.ValueOf() peut obtenir une représentation reflect.Value d'une valeur. Il prend un seul paramètre v, qui peut être n'importe quelle valeur de n'importe quel type. La fonction renvoie une valeur reflect.Value qui représente la valeur du paramètre d'entrée.
L'utilisation de reflect.ValueOf() peut être illustrée par l'exemple suivant :
emballer principalimporter (
'fmt'
'refléter'
)
fonction principal () {
était X float64 = 3 . 14
dans := refléter . Valeur de ( X )
fmt . Imprimerln ( dans ) // Sortie : 3.14
}
Dans cet exemple, nous créons une variable float64 x avec la valeur 3.14. Nous appelons ensuite reflect.ValueOf() pour obtenir une représentation de la valeur de réflexion de x et stockons le résultat dans une variable de valeur de réflexion v. Nous imprimons la valeur de v, qui est 3,14.
Le package reflect fournit de nombreuses fonctions en plus de celles mentionnées, et ce ne sont que quelques exemples. En utilisant les fonctions fournies par le package reflect, nous pouvons créer du code qui peut fonctionner avec des valeurs de n'importe quel type, sans avoir besoin de connaître le type au moment de la compilation.
Conclusion
La réflexion dans Golang permet à un programme d'examiner et de modifier les structures de données, les types et les valeurs lors de l'exécution. Il est implémenté via le package reflect, qui fournit des fonctions pour inspecter et manipuler les types et les valeurs. La réflexion est particulièrement utile lorsque vous travaillez avec des interfaces, des types inconnus ou lorsque vous devez implémenter des fonctions génériques. Cet article traite des bases de la réflexion dans Golang, notamment du package reflect, du type et de la valeur reflect, ainsi que du type et de la valeur dynamiques.