Hvad er strukturer i Golang

Hvad Er Strukturer I Golang



I Go-sprog er en struktur en samling af variabler (felter) grupperet under et enkelt navn. Det er en sammensat datatype, der giver os mulighed for at oprette brugerdefinerede datastrukturer til at holde relaterede oplysninger. Strukturer i Go er som klasser i objektorienteret programmering som C og C++, men de understøtter ikke nedarvning. I stedet er de afhængige af sammensætning for at opnå kodegenbrug. Denne artikel dækker strukturerne i Golang, og hvordan vi kan erklære og få adgang til strukturmedlemmerne.

Hvad er en struktur i Golang

I Golang er en struktur en sammensat datatype, der består af nul eller flere navngivne felter, som hver har en bestemt type. En strukturs felter kan være af enhver type, inklusive andre strukturer, arrays, funktioner eller grænseflader.







Her er et eksempel på en struktur i Golang:



type Personstruktur {
Fuldt navn streng
årgamle int
Sted Adresse
}
type Adressestruktur {
StreetName  streng
Bynavn    streng
Landenavn-streng
}


Her har vi defineret en personstruktur, der har tre felter: Fuldt navn, årgammelt og sted. Feltet Placering er i sig selv en struktur, der har tre felter: Gadenavn, Bynavn og Landnavn.



Sådan erklærer du struktur i Golang

Vi kan erklære en struct i Golang ved hjælp af type søgeord. Navnet på strukturen er defineret efter type søgeord, og dets felter er omgivet af krøllede seler { } . Her er syntaksen til at erklære en struct i Go:





type StructName struct {
Feltnavn1 Felttype1
Feltnavn2 Felttype2
...
}


Nedenfor er et eksempel på, hvordan man deklarerer en struktur ved navn Person med to felter navn og alder af typen henholdsvis streng og int:

type Personstruktur {
navnestreng
alder int
}


I ovenstående kode har vi brugt type nøgleord for at erklære en ny struct navngivet Person med to felter navn af typen streng og alder af typen int. Felterne er adskilt af en Ny linje karakter, men en semikolon (;) kan også bruges til at adskille dem.



Sådan får du adgang til Struct Member i Golang

For at få adgang til felterne i en struct-instans i Go-sproget prik (“.”) operatør bruges. Denne prikoperator efterfølges af et feltnavn. Her er et eksempel på, hvordan du får adgang til navne- og aldersfelterne for en Person struct-instans:

// Opret en ny ` Person ` struct instans med navn 'kash' og alder 24
kash := Person { navn: 'kash' , alder: 24 }

// Få adgang til felterne i ` kash ` struct instans
fmt.Println ( kash.navn ) // Produktion: 'kash'
fmt.Println ( kash.alder ) // Produktion: 24


I ovenstående kode har vi oprettet en ny Person struct-instans ved navn kash med navnet kash og alder 24 . Vi får derefter adgang til navne- og aldersfelterne for kash struct-forekomsten ved hjælp af (“.”) operatør og udskriv dem til konsollen.

Det er vigtigt at bemærke, at felterne i en struct-instans tilgås ved hjælp af punktnotation og ikke pil notation (->) bruges i nogle andre programmeringssprog. Punktnotationen bruges konsekvent på tværs af Go for at få adgang til felter med strukturer, såvel som egenskaber og metoder af andre typer.

Eksempel på kode for erklæring og adgang til strukturmedlemmet i Golang

Nedenfor er et komplet eksempel på at deklarere personstrukturen i Go og udskrive dens værdier på skærmen:

hovedpakke
importere 'fmt'
type Personstruktur {
navnestreng
alder int
}
func hoved ( ) {
// Opret en ny ` Person ` struct instans med navn 'kash' og alder 24
kash := Person { navn: 'kash' , alder: 24 }
// Udskriv ` navn ` og ` alder ` af ` kash ` struct instans til konsollen
fmt.Printf ( 'Navn: %s \n ' , kash.navn )
fmt.Printf ( 'Alder: %d \n ' , kash.alder )
}


I den ovenfor skrevne kode erklærede vi først Person struktur. Denne struktur indeholder to felter, der er navn og alder. Derefter oprettede vi en ny Person struct-instans ved navn kash med navnet kash og alder 24 .

For at vise navne- og aldersfelter bruger vi fmt.Printf funktion med %s og %d formatspecifikationer for at udskrive henholdsvis navne- og aldersfelterne.

Efter kørsel vises kode efter output på konsollen:

Sådan passerer du struktur som funktionsargumenter

For at sende en struct som et funktionsargument i Go, skal vi blot angive struct-typen som parametertypen i funktionssignaturen og derefter sende struct-instansen som et argument, når funktionen kaldes.

Eksempel kode

Nedenstående eksempel viser, hvordan man sender en Person struct-instans som et argument til en funktion i Go-sprog og udskriver dens værdier til skærmen:

hovedpakke
importere 'fmt'
// Erklær en struktur navngivet ` Person ` med to felter: ` navn ` og ` alder `
type Personstruktur {
navnestreng
alder int
}
// Erklære en fungere som hedder ` printPerson ` der tager en ` Person ` struktur som et skænderi
func printPerson ( p Person ) {
fmt.Printf ( 'Navn: %s \n ' , p.navn )
fmt.Printf ( 'Alder: %d \n ' , side )
}
func hoved ( ) {
// Opret en ny ` Person ` struct instans med navn 'kash' og alder 24
kash := Person { navn: 'kash' , alder: 24 }
// Bestå ` kash ` struct instans til ` printPerson ` fungere
printPerson ( kash )
}


I ovenstående kode erklærede vi først Person-strukturen med to felter, navn, og alder . Vi erklærer derefter en funktion ved navn printPerson der tager en personstruktur som et argument og udskriver dens navne- og aldersfelter på skærmen ved hjælp af fmt.Printf-funktionen.

I hovedfunktionen oprettede vi en ny Person struct-instans ved navn kash med navnet kash og alder 24. Vi videregiver derefter kash struct-instansen til printPerson-funktionen ved at kalde printPerson-funktionen og videregive kash som argumentet.

Følgende output kan ses på konsollen efter at have kørt ovenstående kode:

Konklusion

I Golang kan strukturer repræsentere komplekse datatyper og indkapsle relaterede data. En struktur er en datatype, der består af et eller flere felter, som hver får et bestemt navn og type. En strukturs felter kan være af enhver type, inklusive andre strukturer, arrays, funktioner eller grænseflader. Denne artikel diskuterede Go-strukturer i detaljer. Læs artiklen for mere information om deklarering og adgang til struct-elementerne.