Structs à Golang
By
Mohit Kharé
Les structures de Golang sont l'une des plus utilisées et un moyen de créerate types définis par l'utilisateur.
En cela, je couvrirai toutes les bases sur les structures et comment les utiliser dans vos programmes go avec quelques exemples.
Commençons!
Introduction
A struct 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 des deux intégré et le types définis par l'utilisateur (construisez-leself est un type défini par l'utilisateur).
Structs dans Golang mutable c'est-à-dire qu'ils peuvent être modifiés tout au long du programme.
Les structures aident à améliorer la qualité globale du code en nous permettant de créerate et transmettre des structures de données complexes à travers plusieurs modules. Imaginez passer 10 paramètres dans une fonction, vous fuirez bientôt le code. C'est exactement pourquoi les structures sont utiles, désormais, au lieu de 10 paramètres, vous transmettez simplement une seule structure à cette fonction.
Une structure est déclarée à l'aide de deux mots-clés - type et le struct. Il est entouré d'accolades (tout comme les classes dans Java) - qui contient un ensemble de champs qui ont un type défini et un identificateur (nom). Nous discutons des détails de mise en œuvre dans la section suivante.
Si vous venez d'un arrière-plan de 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 le struct sont des mots-clés, alors que la structure 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 un User struct qui se compose de string, int et le float32 des champs. dans le main() nous déclarons notre structure comme user et imprimez-le ! Le résultat que nous obtenons est zero/Valeur vide de la structure puisque nous ne l'avons pas encore initialisée ! Le zero Plus-value est basiqueally zero valeurs de chaque champ.
{0 0}
Initialisation des structures
Dans le prevDans cette section intéressante, nous avons appris à déclarer des structures. Maintenant, nous voudrions les 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 codeself explique comment nous initialisons deux structures avec et sans noms de champs. Ici, le résultat sera –
{Mohit 24 100}
{Nidhi 21 1000}Dans le cas ci-dessus, si l'un des champs n'est pas initialisé, alors ce champ prend par défaut sa valeur zero valeur.
user1 := User{
name: "Mohit",
age: 24,
}
// Output - { Mohit 24 0.0 }Il existe une autre façon de créerate structures utilisant new mot-clé. Nous verrons comment l'utiliser dans la section suivante.
Accéder aux champs d'une structure
Maintenant, nous savons comment créerate et initialisons les structures, voyons comment accéder aux champs d'une structure. Pour cela, Golang nous fournit le opérateur point. Continuer avec le prevExemple intéressant, 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 dans une structure. La sortie du code ci-dessus sera -
Mohit
24
100Comme mentionné précédemment, nous pouvons créerate structure avec new 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 de 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 RoleDetails struct dans le cadre de User struct. La sortie sera -
{Mohit 24 100 {Ingénieur logiciel Transport}}
Si vous souhaitez accéder à roleDetails, vous pouvez le faire en utilisant le même dot opérateur -
user.roleDetails.position
Égalité structurelle
Deux structures sont égales si chacun de leurs champs 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émontrerate é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")
}
}vide et zero les structures de valeur sont égales. L'ordre des champs n'a pas d'importance, c'est basiqueally, chaque champ doit correspondre pour l'égalité. La sortie du code ci-dessus sera –
user1 and user2 are equal
user1 and user3 are not equalConclusion
Génial!
Vous êtes maintenant prêt à utiliser les structures dans golang. Nous avons couvert toutes les bases telles que 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!
