Hva er strukturer i Golang

I Go Language er en struktur en samling av variabler (felt) gruppert under et enkelt navn. Det er en sammensatt datatype som lar oss lage tilpassede datastrukturer for å holde relatert informasjon. Strukturer i Go er som klasser i objektorientert programmering som C, og C ++, men de støtter ikke arv. I stedet er de avhengige av sammensetning for å oppnå gjenbruk. Denne artikkelen dekker strukturene i Golang og hvordan vi kan erklære og få tilgang til Struct -medlemmene.

Hva er en struktur i Golang

I Golang er en struktur en sammensatt datatype som består av null eller flere navngitte felt, som hver har en spesifikk type. Feltene i en struktur kan være av hvilken som helst type, inkludert andre strukturer, matriser, funksjoner eller grensesnitt.

Her er et eksempel på en struktur i Golang:

Skriv person struktur
Fullname streng
Årsolding int
Stedsadresse

Skriv inn adressestruktur
StreetName String
CityName String
Countryname streng

Her har vi definert en personstruktur som har tre felt: fullnavn, årold og beliggenhet. Plasseringsfeltet er i seg selv en struktur som har tre felt: gatenavn, bynavn og landsnavn.

Hvordan erklære struktur i Golang

Vi kan erklære en struktur i Golang ved å bruke type nøkkelord. Navnet på strukturen er definert etter type nøkkelord, og dets felt er vedlagt i krøllete seler . Her er syntaks for å erklære en struktur i GO:

type strukturnavn struktur
Feltname1 FieldType1
Feltname2 FieldType2
..

Nedenfor er et eksempel på hvordan man erklærer en struktur som heter person med to feltnavn og alder på typer streng og henholdsvis int:

Skriv person struktur
Navnstreng
alder int

I koden ovenfor har vi brukt type nøkkelord for å erklære en ny struktur som er navngitt Person med to felt Navn av typen streng og alder av type int. Feltene er atskilt med en Ny linje karakter men a semikolon (;) kan også brukes til å skille dem.

Hvordan få tilgang til Struct Member i Golang

For å få tilgang til feltene til en strukturforekomst på GO -språket punktum (".) operatøren brukes. Denne prikkoperatøren blir fulgt av et feltnavn. Her er et eksempel på hvordan du får tilgang til navn og aldersfelt i en personstruktur forekomst:

// Lag en ny 'person' strukturforekomst med navn "Kash" og 24 år gammel
kash: = person navn: "kash", alder: 24
// Få tilgang til feltene i "Kash" -strukturforekomsten
fmt.Println (Kash.Navn) // Output: "Kash"
fmt.Println (Kash.Alder) // Output: 24

I koden ovenfor har vi opprettet en ny personstrukturforekomst som heter Kash med navnet Kash og alder 24. Vi får deretter tilgang til navnet og aldersfeltene i Kash struct -forekomsten ved å bruke (“.) operatør og skriv dem ut til konsollen.

Det er viktig å merke seg at feltene i en strukturforekomst får tilgang til ved hjelp av DOT -notasjon og ikke pil Notasjon (->) brukt på noen andre programmeringsspråk. Prikknotasjonen brukes konsekvent på tvers av GO for tilgang til felt av strukturer, samt egenskaper og metoder for andre typer.

Eksempelkode for å erklære og få tilgang til Struct -medlemmet i Golang

Nedenfor er et komplett eksempel på å erklære personstrukturen i go og skrive ut verdiene til skjermen:

pakkehoved
Importer "FMT"
Skriv person struktur
Navnstreng
alder int

func main ()
// Lag en ny 'person' strukturforekomst med navn "Kash" og 24 år gammel
kash: = person navn: "kash", alder: 24
// Skriv ut 'Navnet' og 'Age' of 'Kash' Struct -forekomsten til konsollen
fmt.Printf ("Navn: %s \ n", kash.Navn)
fmt.Printf ("alder: %d \ n", kash.alder)

I den ovennevnte koden erklærte vi først Person struktur. Denne strukturen inneholder to felt som er navn og alder. Etter det opprettet vi en ny personstrukturforekomst som heter Kash med navnet Kash og alder 24.

For å vise navn og aldersfelt, bruker vi fmt.Printf funksjon med %s og %d Formatspesifikasjoner for å skrive ut henholdsvis navn- og aldersfeltene.

Etter å ha kjørt vises kode etter utdata på konsollen:

Hvordan passere struktur som funksjonsargumenter

For å passere en struktur som et funksjonsargument i Go, må vi ganske enkelt spesifisere strukturtypen som parametertype i funksjonssignaturen, og deretter passere strukturforekomsten som et argument når du ringer funksjonen.

Eksempelkode

Eksemplet nedenfor viser hvordan du kan gi en personstruktur forekomst som et argument til en funksjon på Go -språk og skrive ut verdiene til skjermen:

pakkehoved
Importer "FMT"
// erklære en struktur som heter 'person' med to felt: 'navn' og 'alder'
Skriv person struktur
Navnstreng
alder int

// erklære en funksjon som heter 'Printperson' som tar en 'person' struktur som et argument
func printperson (p person)
fmt.Printf ("Navn: %s \ n", s.Navn)
fmt.Printf ("alder: %d \ n", s.alder)

func main ()
// Lag en ny 'person' strukturforekomst med navn "Kash" og 24 år gammel
kash: = person navn: "kash", alder: 24
// pass 'Kash' struct -forekomsten til 'Printperson' -funksjonen
Printperson (Kash)

I koden ovenfor erklærte vi først personen strukturen med to felt, Navn, og alder. Vi erklærer da en funksjon som heter Printperson som tar en personstruktur som et argument og skriver ut navn og aldersfelt til skjermen ved hjelp av FMT.Printf -funksjon.

I hovedfunksjonen opprettet vi en ny personstrukturforekomst som heter Kash med navnet Kash og 24 år. Vi passerer deretter Kash Struct -forekomsten til Printperson -funksjonen ved å ringe Printperson -funksjonen og bestå Kash som argumentet.

Følgende utgang kan sees på konsollen etter å ha kjørt koden ovenfor:

Konklusjon

I Golang kan strukturer representere komplekse datatyper og innkapsler relaterte data. En struktur er en datatype som består av ett eller flere felt, som hver får et spesifikt navn og type. Feltene i en struktur kan være av hvilken som helst type, inkludert andre strukturer, matriser, funksjoner eller grensesnitt. Denne artikkelen diskuterte GO -strukturer i detalj, for mer informasjon om å erklære og få tilgang til strukturelementene, les artikkelen.