Golang struct

For kort er en struktur eller struktur en samling felt med definerte datatyper. Strukturer er veldig nyttige og forbedrer fleksibiliteten i programmer. Strukturer er sannsynligvis det beste alternativet hvis du har data som er best representert som en enhet. Tenk på det som en lett versjon av objektorientert programmering.

GO lar deg lage og bruke strukturer ved hjelp av enten innebygde eller brukerdefinerte typer.

Denne guiden vil ta en tur og utforske hvordan strukturer fungerer i Go -programmeringsspråket.

Erklærer en struktur

Syntaksen nedenfor viser hvordan du lager struktur i Go:

typestruct_namestruct
felt_1 data_type
felt_2 data_type
..
FIELD_NDATA_TYPE

Vi starter med å ringe typen nøkkelord. Neste kommer navnet på strukturen. Navnet på strukturen kan være hva som helst brukerdefinert (så lenge den følger reglene for å navngi i Go). Vi bruker deretter Struct nøkkelordet, etterfulgt av et par krøllete seler.

Inne i seler definerer vi forskjellige felt som utgjør strukturen. Feltnavnet blir fulgt av datatypen.

Erklære struktur - eksempel

Eksempelkoden nedenfor definerer en struktur som heter ansatt. Den inneholder 5 felt med forskjellige datatyper.

TypeEmployee struct
Navnstreng
Alder int
Pensjonert bool
Avdelingsstreng
Lønn Float64

Ovennevnte skaper en ansattstruktur som inneholder felt av forskjellige typer.

Merk: Hvis du vil eksportere strukturen og feltene til andre pakker, må du forsikre deg om at navnene starter med store bokstaver. Ellers er omfanget begrenset til den pakken.

Strukturinstantiering

Å definere en struktur betyr at vi bare lager en blåkopi. For å lage et objekt ut av strukturen, må vi lage en forekomst av det.

For å lage en forekomst av en klasse i Go, start med VAR -nøkkelordet etterfulgt av navnet på forekomsten.

Eksemplet nedenfor skaper en forekomst av ansattes struktur.

var emp med ansatt

Når vi har opprettet en forekomst av strukturen, kan vi få tilgang til feltene ved å bruke DOT -notasjonen som vist:

var emp med ansatt
emp.Navn = "Thomas J"
emp.Alder = 35
emp.Pensjonert = falsk
emp.Avdeling = "DevOps Engineer"
emp.Lønn = 130000.50

Når vi har angitt åkrene ved instacen, kan vi skrive det ut som:

fmt.Println (EMP)

Ovennevnte utdrag avkastning:

$ go run structs.gå
Thomas J 35 False DevOps Engineer 130000.5

Struct Instantiation - bokstavelig

Du kan også opprette en forekomst av en struktur ved hjelp av den strukturelle metoden struktur. Eksemplet nedenfor viser bruker struktur bokstavelig for å lage en forekomst av en struktur.

var emp1 = ansatt "Mary A", 26, False, "Game Developer", 150000.10
fmt.Println (EMP1)

Eksemplet ovenfor skaper en forekomst av klassen og setter feltene uten å bruke prikknotasjonen.

Struct Instantiation - Nytt nøkkelord

Hvis du ikke vil angi verdiene under oppretting av instans, kan du bruke det nye nøkkelordet. For eksempel:

var emp2 = ny (ansatt)

Når vi er opprettet, kan vi få tilgang til forekomstfeltene og angi verdier som:

Emp2.Navn = "Judy L"
Emp2.Alder = 60
Emp2.Pensjonist = sant
Emp2.Avdeling = "Menneskelige ressurser"
Emp2.Lønn = 119000.99

Få tilgang til strukturfelt

For å få tilgang til feltene i en struktur, gå gi oss DOT -operatøren. Vi starter med navnet på strukturforekomsten og deretter navnet på feltet.

For å få navnet på EMP2, kan vi for eksempel gjøre:

fmt.Println (EMP2.Navn)

Dette skal returnere verdien som er lagret av det spesifiserte feltet.

Struct Methods

Vi kan også legge til en metode i en struktur ved hjelp av metodemottakeren. Tenk på eksemplet nedenfor som skaper en metode for medarbeiderstrukturen.

func (e ansatt) info () streng
fmt.Printf ("Navn: %s \ n Alder: %d \ n pensjonert: %t \ n avdeling: %s \ n lønn: %f \ n", e.Navn, e.Alder, e.Pensjonist, e.Avdeling, e.Lønn)
Returner "Ferdig"

Når vi har erklært metoden, kan vi opprette en forekomst og sette feltene som:

var ansatt
e.Navn = "Thomas J"
e.Alder = 35
e.Pensjonert = falsk
e.Avdeling = "DevOps Engineer"
e.Lønn = 130000.50

Til slutt kan vi kalle metoden som:

fmt.Println (e.Info ())

Etter metodesamtalen, bør vi få en utdata som:

Navn: Thomas J
Alder: 35
Pensjonert: falsk
Avdeling: DevOps Engineer
Lønn: 130000.500000
Ferdig

Struct felttype

Du kan finne ut hvilken type felt ved hjelp av refleksjonspakken. For å få typen det pensjonerte feltet, kan vi for eksempel gjøre:

fmt.Println (reflekterer.Typeof (e.Pensjonert))

Koden over returnerer felttypen som:

::produksjon
bool

Struktur sammenligning

Du kan sjekke om en struktur er lik en annen ved å bruke sammenligningsoperatøren. Merk at en struktur er definert som lik hvis alle feltene har like verdi.

Merk: Ikke alle datatyper er sammenlignbare.

Eksemplet nedenfor skaper to strukturer og sammenligner dem ved hjelp av == operatøren.

..
var ansatt
e.Navn = "Thomas J"
e.Alder = 35
e.Pensjonert = falsk
e.Avdeling = "DevOps Engineer"
e.Lønn = 130000.50
var emp2 = ny (ansatt)
Emp2.Navn = "Judy L"
Emp2.Alder = 60
Emp2.Pensjonist = sant
Emp2.Avdeling = "Menneskelige ressurser"
Emp2.Lønn = 119000.99
Hvis e == *emp2
fmt.Println ("Strukturer er like")
annet
fmt.Println ("Strukturer ikke like")

..

Siden strukturene ikke er like, utføres andre blokken.

HINT: tomme og null verdier anses som like.

Konklusjon

Puh!

Det var en enestående tutorial om å jobbe med strukturer i Go Lang. Denne opplæringen dekker imidlertid bare det grunnleggende. Det er mange flere operasjoner du kan gjøre med strukturer.

Fortsett å øve, og sjekk ut GO -veiledningene våre for å lære mer.