Les structures, un élément fondamental du langage Go, offrent une méthode puissante pour créer des types de données personnalisés.
Dans ce guide, nous allons explorer en détail les bases des structures et vous montrer comment les utiliser efficacement dans vos programmes Go, en vous fournissant des exemples concrets.
C’est parti !
Introduction
Une structure est un regroupement de données hétérogènes, où chaque donnée (ou champ) possède un type spécifique. Elles permettent de créer des enregistrements personnalisés en combinant des données de différents types. Une structure peut contenir des types de données natifs de Go (comme int, string, float) ainsi que d’autres types définis par l’utilisateur, y compris d’autres structures.
Les structures en Go sont modifiables, ce qui signifie que leurs valeurs peuvent être changées au cours de l’exécution du programme.
Les structures améliorent la clarté et la maintenabilité du code, en permettant de structurer des données complexes et de les transmettre facilement entre différentes parties du programme. Imaginez avoir à passer dix paramètres à une fonction ! Les structures permettent de simplifier cela en passant une seule entité contenant toutes les données nécessaires.
La déclaration d’une structure se fait à l’aide des mots-clés type et struct. Les champs de la structure sont définis entre accolades, à l’instar des classes en Java, et chacun est caractérisé par un nom (identificateur) et un type de données. Nous allons approfondir les détails de mise en œuvre dans la section suivante.
Si vous êtes familier avec la programmation orientée objet, vous pouvez considérer une structure comme une classe sans héritage.
Déclarer des structures
Maintenant que nous avons défini ce qu’est une structure et son utilité, voyons comment la déclarer. La syntaxe de base est la suivante :
type nom_de_la_structure struct {
champ1 type_de_champ1
champ2 type_de_champ2
}
Ici, type et struct sont des mots-clés du langage, et la structure est composée d’une liste de champs, chacun ayant son propre type de données.
Prenons un exemple :
package main
import (
"fmt"
)
type Utilisateur struct {
nom string
age int
soldeBancaire float32
}
func main() {
var utilisateur Utilisateur
fmt.Println(utilisateur)
}
Dans cet exemple, nous définissons une structure `Utilisateur` avec des champs de type string, int, et float32. Dans la fonction `main()`, nous déclarons une variable `utilisateur` de type `Utilisateur` et l’affichons. Le résultat est une structure vide ou avec les valeurs par défaut, car nous ne l’avons pas encore initialisée. Ces valeurs nulles représentent l’état initial de chaque champ.
{ 0 0}
Initialisation des structures
Après avoir vu comment déclarer une structure, il est temps d’apprendre à l’initialiser, c’est-à-dire à donner des valeurs à ses champs. Voici comment procéder :
package main
import (
"fmt"
)
type Utilisateur struct {
nom string
age int
soldeBancaire float32
}
func main() {
// Avec les noms de champs
utilisateur1 := Utilisateur{
nom: "Mohit",
age: 24,
soldeBancaire: 100.0,
}
// Sans les noms de champs
utilisateur2 := Utilisateur{"Nidhi", 21, 1000.0}
fmt.Println(utilisateur1)
fmt.Println(utilisateur2)
}
Le code ci-dessus montre deux manières d’initialiser une structure : en spécifiant les noms de champs, ou sans. L’exécution de ce code donne le résultat suivant :
{Mohit 24 100}
{Nidhi 21 1000}
Si un champ n’est pas explicitement initialisé, il prendra sa valeur par défaut :
utilisateur1 := Utilisateur{
nom: "Mohit",
age: 24,
}
// Output - { Mohit 24 0.0 }
Il existe une autre méthode pour créer des structures, en utilisant le mot-clé `new`. Nous allons l’examiner dans la section suivante.
Accéder aux champs d’une structure
Maintenant que nous savons comment créer et initialiser des structures, voyons comment accéder à leurs champs. Go utilise pour cela l’opérateur point (`.`). Reprenons l’exemple précédent pour accéder et afficher les champs `nom` et `age` :
package main
import (
"fmt"
)
type Utilisateur struct {
nom string
age int
soldeBancaire float32
}
func main() {
// Avec les noms de champs
utilisateur := Utilisateur{
nom: "Mohit",
age: 24,
soldeBancaire: 100.0,
}
fmt.Println(utilisateur.nom)
fmt.Println(utilisateur.age)
fmt.Println(utilisateur.soldeBancaire)
}
Ici, nous utilisons la syntaxe `nom_de_la_structure.nom_du_champ` pour accéder aux champs de la structure. Ce code produira la sortie suivante :
Mohit 24 100
Comme mentionné précédemment, nous pouvons créer des structures en utilisant le mot-clé `new` :
utilisateur := new(Utilisateur)
utilisateur.nom = "Mohit"
utilisateur.age = 24
utilisateur.soldeBancaire = 100.0
fmt.Println(utilisateur)
// Output - &{Mohit 24 100}
Le mot-clé `new` retourne un pointeur vers la structure nouvellement créée. En Go, vous n’avez pas besoin de déréférencer explicitement le pointeur. `fmt.Println(*utilisateur)` donnerait le même résultat.
Structures imbriquées
Les structures en Go peuvent contenir d’autres types définis par l’utilisateur, ce qui permet de créer des structures imbriquées :
package main
import (
"fmt"
)
type Utilisateur struct {
nom string
age int
soldeBancaire float32
detailsRole DetailsRole
}
type DetailsRole struct {
poste string
equipe string
}
func main() {
detailsRoleMohit := DetailsRole{
poste: "Ingénieur Logiciel",
equipe: "Transport",
}
utilisateur := Utilisateur{
nom: "Mohit",
age: 24,
soldeBancaire: 100.0,
detailsRole: detailsRoleMohit,
}
fmt.Println(utilisateur)
}
Dans ce code, la structure `DetailsRole` est imbriquée à l’intérieur de la structure `Utilisateur`. L’exécution de ce code donnera :
{Mohit 24 100 {Ingénieur Logiciel Transport}}
Vous pouvez accéder aux champs de la structure imbriquée de la même manière, en utilisant l’opérateur point :
utilisateur.detailsRole.poste
Comparaison des structures
Deux structures sont considérées comme égales si tous leurs champs sont égaux, qu’il s’agisse de types intégrés ou de types définis par l’utilisateur. Notez cependant que tous les types de données ne sont pas comparables (comme les maps). Voici un exemple pour illustrer la comparaison d’égalité :
package main
import (
"fmt"
)
type Utilisateur struct {
nom string
age int
soldeBancaire float32
}
func main() {
utilisateur1 := Utilisateur{
nom: "Mohit",
age: 24,
soldeBancaire: 100.0,
}
utilisateur2 := Utilisateur{
nom: "Mohit",
age: 24,
soldeBancaire: 100.0,
}
utilisateur3 := Utilisateur{
nom: "Nidhi",
age: 21,
soldeBancaire: 1000.0,
}
if utilisateur1 == utilisateur2 {
fmt.Println("utilisateur1 et utilisateur2 sont égaux")
} else {
fmt.Println("utilisateur1 et utilisateur2 ne sont pas égaux")
}
if utilisateur1 == utilisateur3 {
fmt.Println("utilisateur1 et utilisateur3 sont égaux")
} else {
fmt.Println("utilisateur1 et utilisateur3 ne sont pas égaux")
}
}
Les structures non initialisées (valeurs nulles) sont également considérées comme égales entre elles. L’ordre des champs dans la définition de la structure n’a pas d’importance pour la comparaison, seul le contenu de chaque champ compte. L’exécution de ce code produira la sortie suivante :
utilisateur1 et utilisateur2 sont égaux utilisateur1 et utilisateur3 ne sont pas égaux
Conclusion
Félicitations !
Vous avez désormais les bases nécessaires pour utiliser efficacement les structures en Go. Nous avons couvert la déclaration, l’initialisation, l’accès aux champs, la comparaison d’égalité et l’utilisation de structures imbriquées. Voici quelques ressources pour approfondir vos connaissances sur ce sujet :
Il y a encore beaucoup à explorer concernant les structures, mais ce guide constitue un bon point de départ. J’espère que vous avez appris quelque chose de nouveau !
Continuez à explorer et à apprendre !