Quelles sont les structures à Golang

En langue go, une structure est une collection de variables (champs) regroupées sous un seul nom. Il s'agit d'un type de données composite qui nous permet de créer des structures de données personnalisées pour contenir des informations connexes. Les structures en Go sont comme des classes en programmation orientée objet comme C et C ++, mais elles ne soutiennent pas l'héritage. Au lieu de cela, ils comptent sur la composition pour réaliser le code. Cet article couvre les structures de Golang et comment nous pouvons déclarer et accéder aux membres du struct.

Qu'est-ce qu'une structure à Golang

À Golang, une structure est un type de données composite qui se compose de champs zéro ou plus nommés, chacun ayant un type spécifique. Les champs d'une structure peuvent être de n'importe quel type, y compris d'autres structures, tableaux, fonctions ou interfaces.

Voici un exemple de structure à Golang:

Type personne struct
Chaîne de nom complet
Des années int
Adresse de l'emplacement

Type Address Struct
Chaîne de streetname
Cityname String
Chaîne de nom de country

Ici, nous avons défini une structure de personne qui a trois champs: Fullname, Yeardold et Location. Le champ d'emplacement est lui-même une structure qui a trois champs: StreetName, Cityname et CountryName.

Comment déclarer la structure à Golang

Nous pouvons déclarer une structure à Golang en utilisant le taper mot-clé. Le nom de la structure est défini après taper mot-clé, et ses champs sont enfermés en orthèses bouclées . Voici la syntaxe pour déclarer une structure en Go:

type structName struct
FieldName1 FieldType1
Fieldname2 fieldType2
…

Vous trouverez ci-dessous un exemple de la façon de déclarer une structure nommée personne avec deux champs nom et âge des types chaîne et intrintal: respectivement:

Type personne struct
chaîne de noms
Âge int

Dans le code ci-dessus, nous avons utilisé le taper mot-clé pour déclarer une nouvelle structure nommée Personne avec deux champs nom de type chaîne et âge de type int. Les champs sont séparés par un Nouvelle ligne caractère mais un Semicolon (;) peut également être utilisé pour les séparer.

Comment accéder à un membre de structure à Golang

Pour accéder aux champs d'une instance de structure dans la langue Go point (".») L'opérateur est utilisé. Cet opérateur de points est suivi d'un nom de champ. Voici un exemple de la façon d'accéder aux champs de nom et d'âge d'une instance de structure de personne:

// Créer une nouvelle instance de structure 'Person' avec le nom "Kash" et l'âge de 24 ans
kash: = personne nom: "kash", âge: 24
// Accédez aux champs de l'instance de structure 'Kash'
fmt.Println (kash.Nom) // Sortie: "Kash"
fmt.Println (kash.Âge) // Sortie: 24

Dans le code ci-dessus, nous avons créé une nouvelle instance de struct de personne nommée Kash avec le nom kash Et l'âge 24. Nous accédons ensuite aux champs de nom et d'âge de l'instance Kash Struct en utilisant le (".») opérateur et imprimez-les à la console.

Il est important de noter que les champs d'une instance de structure sont accessibles en utilisant la notation de points et non flèche Notation (->) utilisé dans certains autres langages de programmation. La notation des points est utilisée de manière cohérente en face pour accéder aux champs de structures, ainsi que des propriétés et méthodes d'autres types.

Exemple de code de déclaration et d'accès au membre struct de Golang

Vous trouverez ci-dessous un exemple complet de déclaration de la structure de la personne en Go et d'impression de ses valeurs à l'écran:

package principal
Importer "FMT"
Type personne struct
chaîne de noms
Âge int

func main ()
// Créer une nouvelle instance de structure 'Person' avec le nom "Kash" et l'âge de 24 ans
kash: = personne nom: "kash", âge: 24
// Imprimez l'instance de structure «nom» et «âge» de la console «Kash» à la console
fmt.Printf ("nom:% s \ n", kash.nom)
fmt.Printf ("Age:% d \ n", Kash.âge)

Dans le code ci-dessus, nous avons d'abord déclaré le Personne structure. Cette structure contient deux champs qui sont du nom et de l'âge. Après cela, nous avons créé une nouvelle instance de structure personnelle nommée Kash avec le nom kash Et l'âge 24.

Pour afficher le nom et les champs d'âge, nous utilisons le fmt.Printf fonction avec le % s et %d Format spécificateurs pour imprimer les champs de nom et d'âge, respectivement.

Après l'exécution, le code suivant la sortie apparaît sur la console:

Comment passer les arguments de fonction Struct en fonction

Pour passer un argument structure en fonction de GO, nous devons simplement spécifier le type de structure comme type de paramètre dans la signature de la fonction, puis passer l'instance de structure comme argument lors de l'appel de la fonction.

Exemple de code

L'exemple ci-dessous montre comment passer une instance de structure de personne comme argument à une fonction dans le langage GO et imprimer ses valeurs à l'écran:

package principal
Importer "FMT"
// déclare une structure nommée «personne» avec deux champs: «nom» et «âge»
Type personne struct
chaîne de noms
Âge int

// Déclare une fonction nommée «Printpers» qui prend une structure «personne» comme argument
Func Printerson (P Person)
fmt.Printf ("nom:% s \ n", p.nom)
fmt.Printf ("Âge:% d \ n", p.âge)

func main ()
// Créer une nouvelle instance de structure 'Person' avec le nom "Kash" et l'âge de 24 ans
kash: = personne nom: "kash", âge: 24
// Passez l'instance de structure 'Kash' à la fonction 'Printperson'
Printperson (Kash)

Dans le code ci-dessus, nous avons d'abord déclaré la structure de la personne avec deux champs, nom, et âge. Nous déclarons ensuite une fonction nommée titulaire Cela prend une structure de personne comme argument et imprime son nom et ses champs d'âge à l'écran en utilisant le FMT.Fonction printf.

Dans la fonction principale, nous avons créé une nouvelle instance de struct de personne nommée Kash avec le nom kash et 24 ans. Nous passons ensuite l'instance Kash Struct à la fonction Printperson en appelant la fonction Printerson et en passant kash comme l'argument.

La sortie suivante peut être vue sur la console après avoir exécuté le code ci-dessus:

Conclusion

À Golang, les structures peuvent représenter des types de données complexes et encapsuler des données connexes. Une structure est un type de données composé d'un ou plusieurs champs, chacun étant donné un nom et un type spécifiques. Les champs d'une structure peuvent être de n'importe quel type, y compris d'autres structures, tableaux, fonctions ou interfaces. Cet article a discuté des structures GO en détail, pour plus d'informations sur la déclaration et l'accès aux éléments de structure Lisez l'article.