I Go-språket er en struktur en samling av variabler (felt) gruppert under ett 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 komposisjon for å oppnå kodegjenbruk. Denne artikkelen dekker strukturene i Golang og hvordan vi kan deklarere og få tilgang til strukturmedlemmene.
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 bestemt type. Feltene til 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:
type Personstruktur {
Fullnavn-streng
Årgammel int
Sted Adresse
}
type Adressestruktur {
Gatenavn streng
Bynavn streng
CountryName-streng
}
Her har vi definert en personstruktur som har tre felt: Fullt navn, Årgammelt og Sted. Plasseringsfeltet er i seg selv en struktur som har tre felt: Gatenavn, Bynavn og Landnavn.
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 omsluttet av krøllete klammeparenteser { } . Her er syntaksen for å deklarere en struktur i Go:
type StructName struct {
Feltnavn1 Felttype1
Feltnavn2 Felttype2
...
}
Nedenfor er et eksempel på hvordan du kan deklarere en struktur ved navn Person med to felt navn og alder på typene streng og int henholdsvis:
navnestreng
alder int
}
I koden ovenfor har vi brukt type nøkkelord for å erklære en ny struktur kalt Person med to felt Navn av typen streng og alder av type int. Feltene er atskilt med en Ny linje karakter, men en semikolon (;) kan også brukes til å skille dem.
Hvordan få tilgang til Struct Member i Golang
For å få tilgang til feltene til en struct-forekomst på Go-språket punktum ('.') operatør brukes. Denne punktoperatoren etterfølges av et feltnavn. Her er et eksempel på hvordan du får tilgang til navn- og aldersfeltene til en Person struct-forekomst:
// Lage en ny ` Person ` struktur forekomst med navn 'kash' og alder 24kash := Person { Navn: 'kash' , alder: 24 }
// Få tilgang til feltene til ` kash ` struct-forekomst
fmt.Println ( kash.navn ) // Produksjon: 'kash'
fmt.Println ( kash.alder ) // Produksjon: 24
I koden ovenfor har vi opprettet en ny Person struct-forekomst kalt kash med navnet kash og alder 24 . Vi får deretter tilgang til navn og aldersfelt for kash struct-forekomsten ved å bruke (“.”) operatør og skriv dem ut til konsollen.
Det er viktig å merke seg at feltene til en struct-forekomst åpnes ved hjelp av punktnotasjon og ikke pil notasjon (->) brukes i noen andre programmeringsspråk. Punktnotasjonen brukes konsekvent på tvers av Go for å få tilgang til felt med strukturer, samt egenskaper og metoder av andre typer.
Eksempelkode for erklæring og tilgang til strukturmedlemmet i Golang
Nedenfor er et fullstendig eksempel på hvordan man deklarerer personstrukturen i Go og skriver ut verdiene på skjermen:
hovedpakkeimport 'fmt'
type Personstruktur {
navnestreng
alder int
}
func main ( ) {
// Lage en ny ` Person ` struktur forekomst med navn 'kash' og alder 24
kash := Person { Navn: 'kash' , alder: 24 }
// Skriv ut ` Navn ` og ` alder ` av ` kash ` struct-forekomst til konsollen
fmt.Printf ( 'Navn: %s \n ' , kash.name )
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 Person struct-forekomst kalt 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 aldersfelt.
Etter å ha kjørt, vises kode som følger utdata på konsollen:
Hvordan passere struktur som funksjonsargumenter
For å sende en struct som et funksjonsargument i Go, må vi ganske enkelt spesifisere struct-typen som parametertypen i funksjonssignaturen, og deretter sende struct-forekomsten som et argument når funksjonen kalles.
Eksempelkode
Eksemplet nedenfor viser hvordan du sender en Person struct-forekomst som et argument til en funksjon på Go-språket og skriver ut verdiene på skjermen:
hovedpakkeimport 'fmt'
// Erklær en struktur kalt ` Person ` med to felt: ` Navn ` og ` alder `
type Personstruktur {
navnestreng
alder int
}
// Erklær en funksjon navngitt ` printPerson ` som tar en ` Person ` struktur som et argument
func printPerson ( p Person ) {
fmt.Printf ( 'Navn: %s \n ' , p.navn )
fmt.Printf ( 'Alder: %d \n ' , side )
}
func main ( ) {
// Lage en ny ` Person ` struktur forekomst med navn 'kash' og alder 24
kash := Person { Navn: 'kash' , alder: 24 }
// Send meg ` kash ` struct instans til ` printPerson ` funksjon
printPerson ( kash )
}
I koden ovenfor erklærte vi først Person-strukturen med to felt, Navn, og alder . Vi erklærer deretter en funksjon kalt printPerson som tar en personstruktur som et argument og skriver ut navn og aldersfelt på skjermen ved å bruke funksjonen fmt.Printf.
I hovedfunksjonen opprettet vi en ny Person struct-forekomst kalt kash med navnet kash og alder 24. Vi sender deretter kash struct-forekomsten til printPerson-funksjonen ved å kalle printPerson-funksjonen og sende 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 innkapsle relaterte data. En struktur er en datatype som består av ett eller flere felt, som hvert får et bestemt navn og type. Feltene til 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 å deklarere og få tilgang til strukturelementene, les artikkelen.