Comment attribuer des valeurs par défaut aux champs struct dans Golang ?

Comment Attribuer Des Valeurs Par Defaut Aux Champs Struct Dans Golang



Golang est un langage de programmation moderne qui a gagné en popularité ces dernières années. L'une des fonctionnalités puissantes de Golang est sa capacité à définir et à manipuler des structures. Structures sont des types de données définis par l'utilisateur qui permettent aux développeurs de regrouper des champs de données connexes dans un seul objet. Au Go, structures peut avoir les valeurs par défaut affectés à leurs champs, ce qui facilite grandement leur initialisation.

Dans cet essai, nous verrons comment attribuer un valeur par défaut pour un champ struct dans Golang.

Que sont les champs de structure ?

Tout d'abord, il est essentiel de comprendre le concept de champs de structure . Le champs de structure sont des variables qui sont regroupées pour former un structure objet. Chaque champ de structure a un nom et un type de données. Par exemple, une structure qui représente une personne peut avoir des champs tels que le nom, l'âge et le sexe.







Comment attribuer des valeurs par défaut aux champs Struct dans Golang ?

Les valeurs par défaut peut être attribué pour les champs struct dans Go en utilisant :



  • Valeurs zéro par défaut
  • Constructeurs
  • Littéraux de structure
  • Valeurs de champ par défaut

1 : Valeurs zéro par défaut

Dans Go, l'attribution de valeurs par défaut aux champs struct peut être réalisée avec le ' valeur zéro ' fonctionnalité. Cette fonctionnalité attribue automatiquement une valeur par défaut de ' 0 ' ou ' FAUX ” à chaque champ non initialisé, selon le type de données. Cela signifie que vous n'avez pas à définir explicitement des valeurs par défaut pour chaque champ de la structure, car Go le fera pour vous.



Cette fonctionnalité peut être utile lorsqu'il s'agit de structures volumineuses avec de nombreux champs, car elle permet d'économiser du temps et des efforts pour définir manuellement les valeurs par défaut de chaque champ.





Voici un exemple qui utilise la valeur zéro pour attribuer des valeurs par défaut aux champs struct :

paquet principal

importer 'fmt'

taper Structure de personne {
Chaîne de nom
Âge    int
Hauteur flotteur64
IsMale booléen
}

fonction principale ( ) {
p1 := Personne { Nom: 'John' , Âge: 30 }
fmt.Println ( p1.Nom )
fmt.Println ( p1.Âge )
fmt.Println ( p1.Hauteur )
fmt.Println ( p1.IsMale )
}

Le code ci-dessus définit une personne structure avec quatre champs : Name, Age, Height et IsMale, qui sont tous du type de données bool. Ensuite, nous créons une nouvelle instance de la classe Person, p1, et initialisons certains de ses champs en utilisant des littéraux de structure pour spécifier les noms et les valeurs des champs. Le valeurs zéro par défaut pour les champs qui n'ont pas été explicitement définis lors de l'initialisation s'affichent lorsque vous imprimez les valeurs des champs à l'aide de fmt.Println .



Sortir

2 : Constructeurs

En écrivant un constructeur fonction pour la structure, vous pouvez également donner des valeurs par défaut aux champs de structure dans Golang. Le constructeur La fonction crée une nouvelle instance de la structure et définit les valeurs par défaut pour ses champs. Cette méthode permet d'économiser des efforts et du temps, en particulier lors de l'interaction avec d'énormes structures avec de nombreux champs.

Voici un exemple de définition d'un constructeur fonction avec des valeurs de champ par défaut pour une structure :

paquet principal

importer 'fmt'

taper Structure de personne {
Nom    chaîne
Âge     int
Chaîne d'adresse
}
fonction NouvellePersonne ( ) * Personne {
retour & Personne {
Nom: 'John Doe' ,
Âge: 30 ,
Adresse: '123 rue principale' ,
}
}
fonction principale ( ) {
p := NouvellePersonne ( )
fmt.Println ( p.Nom, p.Âge, p.Adresse )
}

Dans le code ci-dessus, un Personne struct est défini, ainsi que la nouvelle personne() fonction, qui produit une nouvelle instance de la Personne structure avec des valeurs par défaut prédéterminées. Nous appelons nouvelle personne() dans principal() pour créer une nouvelle instance Person avec valeurs de champ par défaut , puis nous imprimons les valeurs des champs de cette instance.

Sortir

3 : littéraux de structure

Dans Golang, vous pouvez définir des valeurs par défaut pour les champs struct en utilisant littéraux de structure aussi. Construisez simplement une nouvelle instance de la structure et définissez les valeurs pour chaque champ qui doit être initialisé. Si vous souhaitez définir des valeurs par défaut pour les champs que vous n'initialisez pas explicitement, vous pouvez utiliser la fonctionnalité de valeur zéro.

Voici un exemple d'utilisation littéraux de structure pour définir des valeurs de champ par défaut pour une structure :

paquet principal

importer 'fmt'

taper Structure de personne {
Nom    chaîne
Âge     int
Chaîne d'adresse
}
fonction principale ( ) {
p := Personne {
Nom: 'John Doe' ,
Âge: 30 ,
}
fmt.Println ( p.Nom, p.Âge, p.Adresse )
}

Dans le code ci-dessus, nous définissons un Personne struct dans cet exemple et créez une nouvelle instance de celui-ci en utilisant un littéral de struct et des valeurs par défaut pour ses champs. Un nouveau Personne instance est créée dans main() avec certaines valeurs de champ renseignées et d'autres laissées vides. Depuis le Adresse champ n'est pas initialisé, il reçoit la chaîne vide qui est la valeur par défaut de ce champ. Enfin, nous imprimons les valeurs des champs de l'instance Person.

Sortir

4 : Valeurs de champ par défaut

Affectation les valeurs par défaut pour champs de structure dans Go est un processus simple. Le valeur par défaut pour un champ struct peut être défini à l'aide de la syntaxe nom du champ : valeur par défaut . Par exemple, considérez la définition de structure suivante :

taper Structure de personne {
Chaîne de nom
Âge entier
Chaîne de genre
}

Assigner les valeurs par défaut aux champs de cette structure, nous pouvons utiliser la syntaxe suivante :

p := Personne {
Nom: 'John Doe' ,
Âge: 30 ,
Genre: 'Homme' ,
}

Dans l'exemple ci-dessus, nous avons attribué les valeurs par défaut aux champs de la structure Person. Si nous omettons l'une des valeurs lors de l'initialisation, le valeur par défaut sera utilisé à la place. Par exemple, si nous initialisons un objet Person comme ceci :

p := Personne {
Nom: 'Jane Doe' ,
}

L'objet Person résultant aura la valeur les valeurs par défaut pour les champs Âge et Sexe, qui sont respectivement 0 et une chaîne vide.

Voici un code complet qui illustre le processus ci-dessus :

paquet principal
importer 'fmt'

taper Structure de personne {
Chaîne de nom
Âge    int
Chaîne de genre
}
fonction principale ( ) {
p1 := Personne {
Nom: 'John Doe' ,
Âge: 30 ,
Genre: 'Homme' ,
}
fmt.Println ( p1 )

p2 := Personne {
Nom: 'Jérémy' ,
}
fmt.Println ( p2 )
}

Dans l'exemple ci-dessus, nous construisons une structure Person qui a trois champs : Name, un int représentant l'âge, et Gender, une chaîne représentant le sexe. La syntaxe d'initialisation de struct est ensuite utilisée pour construire deux instances Person, p1 et p2. p1 est initialisé avec les valeurs « John Doe » pour le nom, « 30 » pour l'âge et « Homme » pour le sexe, qui sont toutes des valeurs qui ont été expressément fournies. Comme nous n'avons pas donné de valeurs pour l'âge et le sexe, les valeurs par défaut de 0 et une chaîne vide, respectivement, leur seront attribuées. p2 est initialement initialisé avec uniquement le champ Nom fourni.

Sortir

Conclusion

Affectation les valeurs par défaut in Go est un aspect essentiel de la programmation avec ce langage. Cela permet de s'assurer que chaque instance de struct créée a des données par défaut qui lui sont assignées. En utilisant l'une des méthodes expliquées ci-dessus, les développeurs peuvent définir le les valeurs par défaut de champs de structure efficacement.