|
## Structures
- Les structures Golang nous permettent de regrouper des données.
- Elles sont similaires aux structures d'autres langages de programmation.
- Les structures sont des types de données définis par l'utilisateur et vous permettent de créer vos propres types personnalisés.
- Les structures peuvent contenir tout type de données, y compris d'autres structures.
Définition de la structure :
``` va
tapez nom_structure struct {
nom_membre type1
nom_membre type2
...
nom_membre typeN
}
```
- Ceci définit une structure nommée `structure_name` avec des membres `member_name`. Chaque membre a un type, qui peut être n’importe quel type Go valide.
Créer des structures :
``` va
var nom_structure =type_structure {
nom_membre1 :valeur1,
nom_membre2 :valeur2,
...
nom_membreN :valeurN
}
```
- Cela crée une variable de type `structure_name` et initialise ses membres avec les valeurs données.
Accéder aux membres :
- Pour accéder à un membre de la structure, utilisez l'opérateur point :`structure_name.member_name`.
Exemple :
``` va
// Définissez une structure nommée personne avec les membres nom et âge.
tapez personne struct {
Chaîne de nom
Âge entier
}
fonction main() {
// Créez une personne nommée "John Doe".
personne1 :=personne{"John Doe", 30}
// Affiche le nom et l'âge de John.
fmt.Println("Nom:", personne1.Nom)
fmt.Println("Âge :", personne1.Âge)
}
```
Structures nommées :
- Si une structure contient des champs de types de données de base, alors elle peut être déclarée sans mot-clé struct.
``` va
tapez la structure MyStruct {
un int
b float32
chaîne c
}
tapez votre structure {
f int 'json:"premier"'
l chaîne 'json:"dernier"'
}
```
- Pour « MyStruct » et « votre struct » ci-dessus, le mot-clé struct est facultatif
Structures anonymes
- Des structures anonymes peuvent être utilisées pour créer des types de données ad hoc sans définir explicitement un type de structure.
- Lorsqu'une structure anonyme est utilisée comme champ d'une autre structure ou comme élément d'une tranche/carte, le type du champ est la structure anonyme et la balise du champ est le nom du type.
``` va
tapez Structure de personne {
chaîne de nom
âge entier
}
```
- Alternativement, des structures anonymes peuvent être utilisées pour instancier une structure sans définir de type struct.
``` va
var personne =struct {
chaîne de nom
âge entier
}{nom :"Bob", âge :20}
```
- Dans ce cas, la variable personne de type `struct{ name string; age int }` est créé et initialisé.
Intégrer des structures
- L'intégration d'une structure dans une autre structure permet une forme d'héritage dans Go.
``` va
tapez Structure de personne {
chaîne de nom
âge entier
}
tapez la structure de l'employé {
salaire entier
Personne
}
```
- Ici, « Employé » intègre « Personne » donc une variable « Employé » inclura les champs de « Personne » (nom et âge) ainsi que ses propres champs.
``` va
emp :=Employé{salaire :100 000, Personne :Personne{nom :"John", âge :30}}
fmt.Println(emp.salaire) // 100000
fmt.Println(emp.name) // John
```
- Les champs de la structure intégrée sont promus vers la structure externe (contenante) comme s'ils étaient déclarés dans la structure conteneur. Ici, les champs `name` et `age` de `Person` sont désormais accessibles sur la variable `Employee` (`emp`).
Balises dans les structures
- Des balises peuvent être attachées aux champs de structure pour fournir des informations supplémentaires. Ces balises sont utilisées par la réflexion et les encodeurs/décodeurs.
``` va
tapez Structure de personne {
chaîne de nom `json:"name"` // balise json
âge int `xml:"age"` // balise xml
}
```
- Les balises sont entourées de guillemets (« ») si elles contiennent des espaces ou d'autres caractères spéciaux.
Conclusion
- Les structures permettent de regrouper les données associées et de créer vos types de données personnalisés dans Go.
- Des structures nommées et anonymes peuvent être utilisées en fonction de la situation, et l'intégration permet une forme d'héritage.
- Des balises peuvent être attachées aux champs de structure pour des métadonnées supplémentaires et une compatibilité avec les bibliothèques standard.
|
