I Go-språk är en struktur en samling variabler (fält) grupperade under ett enda namn. Det är en sammansatt datatyp som låter oss skapa anpassade datastrukturer för att hålla relaterad information. Strukturer i Go är som klasser i objektorienterad programmering som C och C++, men de stöder inte arv. Istället förlitar de sig på komposition för att uppnå kodåteranvändning. Den här artikeln täcker strukturerna i Golang och hur vi kan deklarera och komma åt strukturmedlemmarna.
Vad är en struktur i Golang
I Golang är en struktur en sammansatt datatyp som består av noll eller fler namngivna fält, som vart och ett har en specifik typ. Fälten i en struktur kan vara av vilken typ som helst, inklusive andra strukturer, arrayer, funktioner eller gränssnitt.
Här är ett exempel på en struktur i Golang:
typ Personstruktur {
FullName sträng
Årgamla int
Plats Adress
}
typ Adressstruktur {
StreetName sträng
Stadsnamn sträng
CountryName sträng
}
Här har vi definierat en personstruktur som har tre fält: Fullständigt namn, Årsgammalt och Plats. Fältet Plats är i sig en struktur som har tre fält: Gatunamn, Stadsnamn och Landsnamn.
Hur man deklarerar struktur i Golang
Vi kan deklarera en struktur i Golang med hjälp av typ nyckelord. Namnet på strukturen definieras efter typ nyckelord, och dess fält omges av hängslen { } . Här är syntaxen för att deklarera en struktur i Go:
typ StructName struct {
Fältnamn1 Fälttyp1
Fältnamn2 Fälttyp2
...
}
Nedan är ett exempel på hur man deklarerar en struktur med namnet Person med två fält namn och ålder av typerna string respektive int:
namnsträng
ålder int
}
I ovanstående kod har vi använt typ nyckelord för att deklarera en ny struktur som heter Person med två fält namn av typ sträng och ålder av typ int. Fälten är åtskilda av en Ny linje karaktär men a semikolon (;) kan också användas för att separera dem.
Hur man kommer åt Struct Member i Golang
För att komma åt fälten för en struct-instans i Go-språket prick (“.”) operatör används. Denna punktoperator följs av ett fältnamn. Här är ett exempel på hur du får åtkomst till namn- och åldersfälten för en Person struct-instans:
// Skapa en ny ` Person ` struct instans med namn 'kash' och ålder 24kash := Person { namn: 'kash' , ålder: 24 }
// Få tillgång till fälten för ` kash ` struct instans
fmt.Println ( kash.name ) // Produktion: 'kash'
fmt.Println ( kash.ålder ) // Produktion: 24
I ovanstående kod har vi skapat en ny Person struct-instans som heter kash med namnet kash och ålder 24 . Vi kommer sedan åt namn- och åldersfälten för kash struct-instansen med hjälp av (“.”) operatör och skriv ut dem till konsolen.
Det är viktigt att notera att fälten i en struct-instans nås med hjälp av punktnotation och inte pil notation (->) används i vissa andra programmeringsspråk. Punktnotationen används konsekvent över Go för att komma åt strukturfält, såväl som egenskaper och metoder av andra typer.
Exempelkod för att deklarera och få tillgång till strukturmedlemmen i Golang
Nedan är ett komplett exempel på hur man deklarerar personstrukturen i Go och skriver ut dess värden på skärmen:
huvudpaketetimportera 'fmt'
typ Personstruktur {
namnsträng
ålder int
}
func huvud ( ) {
// Skapa en ny ` Person ` struct instans med namn 'kash' och ålder 24
kash := Person { namn: 'kash' , ålder: 24 }
// Skriv ut ` namn ` och ` ålder ` av ` kash ` struct-instans till konsolen
fmt.Printf ( 'Namn: %s \n ' , kash.name )
fmt.Printf ( 'Ålder: %d \n ' , kash.ålder )
}
I den ovan skrivna koden deklarerade vi först Person struktur. Denna struktur innehåller två fält som är namn och ålder. Efter det skapade vi en ny Person struct-instans som heter kash med namnet kash och ålder 24 .
För att visa namn och åldersfält använder vi fmt.Printf funktion med %s och %d formatspecifikationer för att skriva ut namn- respektive åldersfälten.
Efter körning visas följande kod på konsolen:
Hur man skickar struktur som funktionsargument
För att skicka en struct som ett funktionsargument i Go måste vi helt enkelt ange struct-typen som parametertypen i funktionssignaturen och sedan skicka struct-instansen som ett argument när funktionen anropas.
Exempelkod
Exemplet nedan visar hur man skickar en Person struct-instans som ett argument till en funktion i Go-språket och skriver ut dess värden på skärmen:
huvudpaketetimportera 'fmt'
// Deklarera en struktur som heter ` Person ` med två fält: ` namn ` och ` ålder `
typ Personstruktur {
namnsträng
ålder int
}
// Deklarera a fungera som heter ` printPerson ` som tar en ` Person ` struktur som ett argument
func printPerson ( p Person ) {
fmt.Printf ( 'Namn: %s \n ' , p.namn )
fmt.Printf ( 'Ålder: %d \n ' , sid )
}
func huvud ( ) {
// Skapa en ny ` Person ` struct instans med namn 'kash' och ålder 24
kash := Person { namn: 'kash' , ålder: 24 }
// Skicka ` kash ` struct instans till ` printPerson ` fungera
printPerson ( kash )
}
I ovanstående kod deklarerade vi först personstrukturen med två fält, namn, och ålder . Vi deklarerar sedan en funktion som heter printPerson som tar en personstruktur som ett argument och skriver ut dess namn- och åldersfält på skärmen med funktionen fmt.Printf.
I huvudfunktionen skapade vi en ny Person struct-instans med namnet kash med namnet kash och ålder 24. Vi skickar sedan kash struct-instansen till printPerson-funktionen genom att anropa printPerson-funktionen och skicka kash som argument.
Följande utdata kan ses på konsolen efter att ha kört ovanstående kod:
Slutsats
I Golang kan strukturer representera komplexa datatyper och kapsla in relaterade data. En struktur är en datatyp som består av ett eller flera fält, som vart och ett får ett specifikt namn och typ. Fälten i en struktur kan vara av vilken typ som helst, inklusive andra strukturer, arrayer, funktioner eller gränssnitt. Den här artikeln diskuterade Go-strukturer i detalj, för mer information om att deklarera och komma åt strukturelementen, läs artikeln.