## Strukturer
– Golang-strukturer lar oss gruppere data sammen.
– De ligner på strukturer i andre programmeringsspråk.
– Strukturer er brukerdefinerte datatyper, og de lar deg lage dine egne tilpassede typer.
- Strukturer kan inneholde alle typer data, inkludert andre strukturer.
Strukturdefinisjon:
``` gå
skriv strukturnavn struct {
medlemsnavn type1
medlemsnavn type2
...
medlemsnavn typeN
}
```
- Dette definerer en struktur kalt `strukturnavn` med medlemmene `medlemsnavn`. Hvert medlem har en type, som kan være en hvilken som helst gyldig Go-type.
Opprette strukturer:
``` gå
var strukturnavn =strukturtype {
medlemsnavn1:verdi1,
medlemsnavn2:verdi2,
...
medlemsnavnN:verdiN
}
```
- Dette oppretter en variabel av typen `strukturnavn` og initialiserer medlemmene med de gitte verdiene.
Tilgang til medlemmer:
- For å få tilgang til et strukturmedlem, bruk punktoperatoren:`strukturnavn.medlemsnavn`.
Eksempel:
``` gå
// Definer en struktur navngitt person med navn og aldersmedlemmer.
type person struct {
Navnestreng
Alder int
}
func main() {
// Lag en person som heter "John Doe".
person1 :=person{"John Doe", 30}
// Skriv ut Johns navn og alder.
fmt.Println("Navn:", person1.Navn)
fmt.Println("Alder:", person1.Alder)
}
```
Navngitte strukturer:
- Hvis en struktur inneholder felt med grunnleggende datatyper, kan den deklareres uten et struct-nøkkelord.
``` gå
type MyStruct struct {
en int
b flyte32
c streng
}
skriv inn struct {
f int 'json:"first"'
l string 'json:"last"'
}
```
- For både `MyStruct` og `din struct` ovenfor, er nøkkelordet struct valgfritt
Anonyme strukturer
- Anonyme strukturer kan brukes til å lage ad-hoc datatyper uten å definere en strukturtype eksplisitt.
- Når en anonym struktur brukes som et felt i en annen struktur eller som et element i en skive/kart, er feltets type den anonyme strukturen og feltets tag er typenavnet.
``` gå
type Person struct {
navnestreng
alder int
}
```
- Alternativt kan anonyme strukturer brukes til å instansiere en struktur uten å definere en strukturtype.
``` gå
var person =struct {
navnestreng
alder int
}{navn:"Bob", alder:20}
```
- I dette tilfellet, variabelen person av typen `struct{ navnestreng; age int }` opprettes og initialiseres.
Innebyggingsstrukturer
- Å bygge inn en struktur i en annen struktur gir mulighet for en form for arv i Go.
``` gå
type Person struct {
navnestreng
alder int
}
type Employee struct {
lønn int
Person
}
```
- Her legger `Employee` inn `Person` slik at en `Employee`-variabel vil inkludere feltene fra `Person` (navn og alder) så vel som sine egne felt.
``` gå
emp :=Ansatt{lønn:100000, Person:Person{navn:"John", alder:30}}
fmt.Println(emp.lønn) // 100000
fmt.Println(emp.name) // John
```
- Feltene til den innebygde strukturen forfremmes til den ytre (inneholdende) strukturen som om de var deklarert i den inneholdende strukturen. Her kan nå feltene `navn` og `alder` til `Person` nås på `Employee`-variabelen (`emp`).
Tagger i strukturer
- Tagger kan festes til strukturfelt for å gi tilleggsinformasjon. Disse taggene brukes av refleksjon og kodere/dekodere.
``` gå
type Person struct {
navnestreng `json:"navn"` // json-tag
age int `xml:"age"` // xml-tag
}
```
- Taggene er omsluttet av bakmerker (‘`’) hvis de inneholder mellomrom eller andre spesialtegn.
Konklusjon
- Strukturer gir en måte å gruppere relaterte data sammen og lage dine egendefinerte datatyper i Go.
– Navngitte og anonyme strukturer kan brukes avhengig av situasjonen, og innbygging åpner for en form for arv.
- Tagger kan festes til strukturfelt for ytterligere metadata og kompatibilitet med standardbiblioteker.