Les structures dans Golang sont l’une des plus utilisées et un moyen de créer des types définis par l’utilisateur.
Dans ce document, je couvrirai toutes les bases des structures et comment les utiliser dans vos programmes go avec quelques exemples.
Commençons!
Table des matières
Introduction
UN structure est une collection de plusieurs champs de données avec leurs types de données définis regroupés. Ils sont utiles pour regrouper des données afin de former des enregistrements personnalisés. Une structure se compose à la fois de types intégrés et de types définis par l’utilisateur (la structure elle-même est un type défini par l’utilisateur).
Les structures de Golang sont modifiables, c’est-à-dire qu’elles peuvent être modifiées tout au long du programme.
Les structures aident à améliorer la qualité globale du code en nous permettant de créer et de transmettre des structures de données complexes à travers plusieurs modules. Imaginez passer 10 paramètres dans une fonction, vous allez bientôt fuir le code. C’est exactement pourquoi les structures sont utiles, maintenant au lieu de 10 paramètres, vous passez simplement une seule structure à cette fonction.
Une structure est déclarée à l’aide de deux mots-clés – taper et structure. Il est entouré d’accolades (tout comme les classes en Java) – qui contient un ensemble de champs qui ont un type défini et un identifiant (nom). Nous discutons des détails de mise en œuvre dans la section suivante.
Si vous venez d’un milieu de la programmation orientée objet (POO), vous pouvez considérer struct comme une classe mais sans héritage.
Déclarer des structures
Maintenant que vous comprenez ce qu’est une structure et pourquoi elle est utilisée, il est temps d’apprendre à déclarer des structures. Le squelette de base d’une structure ressemble à –
type name_of_struct struct {
field1 data_type_field1
field2 data_type_field2
}Ici, type et struct sont des mots-clés, alors que la struct contient plusieurs champs avec leur type de données défini.
Voyons un exemple –
package main
import (
"fmt"
)
type User struct {
name string
age int
bankBalance float32
}
func main() {
var user User
fmt.Println(user)
}Ici, nous définissons une structure User composée de champs string, int et float32. Dans le main() nous déclarons notre structure en tant qu’utilisateur et l’affichons ! La sortie que nous obtenons est la valeur zéro/vide de la structure puisque nous ne l’avons pas encore initialisée ! La valeur zéro est fondamentalement des valeurs nulles de chaque champ.
{ 0 0}Initialisation des structures
Dans la section précédente, nous avons appris à déclarer des structures. Maintenant, nous voudrions initialiser ou leur attribuer des valeurs. Vérifiez le code ci-dessous pour savoir comment nous procédons –
package main
import (
"fmt"
)
type User struct {
name string
age int
bankBalance float32
}
func main() {
// With field names
user1 := User{
name: "Mohit",
age: 24,
bankBalance: 100.0,
}
// Without field names
user2 := User{"Nidhi", 21, 1000.0}
fmt.Println(user1)
fmt.Println(user2)
}Le code lui-même explique comment nous initialisons deux structures avec et sans noms de champ. Ici, la sortie sera –
{Mohit 24 100}
{Nidhi 21 1000}Dans le cas ci-dessus, si l’un des champs n’est pas initialisé, ce champ prend par défaut sa valeur zéro.
user1 := User{
name: "Mohit",
age: 24,
}
// Output - { Mohit 24 0.0 }Il existe une autre façon de créer des structures en utilisant un nouveau mot-clé. Nous verrons comment l’utiliser dans la section suivante.
Accéder aux champs d’une structure
Maintenant que nous savons créer et initialiser des structs, voyons comment accéder aux champs d’un struct. Pour cela, Golang nous fournit l’opérateur point. En continuant avec l’exemple précédent, accédons aux champs de nom et d’âge et imprimons-les.
package main
import (
"fmt"
)
type User struct {
name string
age int
bankBalance float32
}
func main() {
// With field names
user := User{
name: "Mohit",
age: 24,
bankBalance: 100.0,
}
fmt.Println(user.name)
fmt.Println(user.age)
fmt.Println(user.bankBalance)
}Ici, nous utilisons struct_name.field_name pour accéder aux champs d’une structure. La sortie du code ci-dessus sera –
Mohit 24 100
Comme mentionné précédemment, nous pouvons créer des structures avec un nouveau mot-clé. Voyons comment –
user := new(User)
user.name = "Mohit"
user.age = 24
user.bankBalance = 100.0
fmt.Println(user)
// Output - &{Mohit 24 100}Le nouveau mot-clé renvoie le pointeur vers la structure initialisée. Dans Golang, vous n’avez pas besoin de déréférencer explicitement le pointeur, mais fmt.Println(*user) donnerait le même résultat.
Structures imbriquées
Les structures dans golang peuvent également contenir d’autres types définis par l’utilisateur. Ainsi, une structure peut contenir d’autres structures imbriquées.
package main
import (
"fmt"
)
type User struct {
name string
age int
bankBalance float32
roleDetails RoleDetails
}
type RoleDetails struct {
position string
team string
}
func main() {
roleDetailForMohit := RoleDetails{
position: "Software Engineer",
team: "Transport",
}
user := User{
name: "Mohit",
age: 24,
bankBalance: 100.0,
roleDetails: roleDetailForMohit,
}
fmt.Println(user)
}Dans le code ci-dessus, nous avons la structure RoleDetails dans le cadre de la structure User. La sortie sera –
{Mohit 24 100 {Software Engineer Transport}}
Si vous souhaitez accéder à roleDetails, vous pouvez le faire en utilisant le même opérateur point –
user.roleDetails.position
Structurer l’égalité
Deux structures sont égales si chacun des champs qu’elles ont est égal (à la fois intégré et défini par l’utilisateur) mais tous les types de données ne sont pas comparables. (la carte n’est pas comparable directement). Voyons un exemple pour démontrer l’égalité.
package main
import (
"fmt"
)
type User struct {
name string
age int
bankBalance float32
}
func main() {
user1 := User{
name: "Mohit",
age: 24,
bankBalance: 100.0,
}
user2 := User{
name: "Mohit",
age: 24,
bankBalance: 100.0,
}
user3 := User{
name: "Nidhi",
age: 21,
bankBalance: 1000.0,
}
if user1 == user2 {
fmt.Println("user1 and user2 are equal")
} else {
fmt.Println("user1 and user2 are not equal")
}
if user1 == user3 {
fmt.Println("user1 and user3 are equal")
} else {
fmt.Println("user1 and user3 are not equal")
}
}Les structures de valeur vide et nulle sont égales. L’ordre des champs n’a pas d’importance, fondamentalement, chaque champ doit correspondre à l’égalité. La sortie pour le code ci-dessus sera –
user1 and user2 are equal user1 and user3 are not equal
Conclusion
Impressionnant!
Vous êtes maintenant prêt à utiliser des structures dans golang. Nous avons couvert toutes les bases comme la déclaration, l’initialisation et l’accès aux champs de structure. Nous avons également examiné comment comparer deux structures et même implémenté une structure imbriquée. Voici quelques ressources pour en savoir plus sur les structures –
Il y a beaucoup plus à apprendre sur les structures, mais c’est un bon début pour le moment. J’espère que vous avez appris quelque chose de nouveau !
Continuez à explorer. Continue d’apprendre!