## Strukturer
- Golang-strukturer giver os mulighed for at gruppere data sammen.
- De ligner strukturer i andre programmeringssprog.
- Strukturer er brugerdefinerede datatyper, og de giver dig mulighed for at oprette dine egne brugerdefinerede typer.
- Strukturer kan indeholde enhver type data, inklusive andre strukturer.
Strukturdefinition:
``` gå
skriv strukturnavn struct {
medlemsnavn type1
medlemsnavn type2
...
medlemsnavn typeN
}
```
- Dette definerer en struktur med navnet `strukturnavn` med medlemmerne `medlemsnavn`. Hvert medlem har en type, som kan være en hvilken som helst gyldig Go-type.
Oprettelse af strukturer:
``` gå
var struktur_navn =struktur_type {
medlemsnavn1:værdi1,
medlemsnavn2:værdi2,
...
medlemsnavnN:værdiN
}
```
- Dette opretter en variabel af typen `strukturnavn` og initialiserer dens medlemmer med de givne værdier.
Adgang til medlemmer:
- For at få adgang til et strukturmedlem skal du bruge prikoperatoren:`strukturnavn.medlemsnavn`.
Eksempel:
``` gå
// Definer en struktur navngivet person med navn og alder medlemmer.
type person struct {
Navnestreng
Alder int
}
func main() {
// Opret en person ved navn "John Doe".
person1 :=person{"John Doe", 30}
// Udskriv Johns navn og alder.
fmt.Println("Navn:", person1.Navn)
fmt.Println("Alder:", person1.Alder)
}
```
Navngivne strukturer:
- Hvis en struktur indeholder felter med grundlæggende datatyper, så kan den erklæres uden et struct nøgleord.
``` gå
type MyStruct struct {
en int
b float32
c streng
}
skriv din struct {
f int 'json:"første"'
l string 'json:"sidste"'
}
```
- For både 'MyStruct' og 'din struct' ovenfor er nøgleordet struct valgfrit
Anonyme strukturer
- Anonyme strukturer kan bruges til at skabe ad-hoc datatyper uden at definere en strukturtype eksplicit.
- Når en anonym struktur bruges som et felt i en anden struktur eller som et element i et udsnit/kort, er feltets type den anonyme struktur, og feltets tag er typenavnet.
``` gå
type Person struct {
navnestreng
alder int
}
```
- Alternativt kan anonyme strukturer bruges til at instansiere en struktur uden at definere en strukturtype.
``` gå
var person =struct {
navnestreng
alder int
}{navn:"Bob", alder:20}
```
- I dette tilfælde variablen person af typen `struct{ navnestreng; age int }` oprettes og initialiseres.
Indlejring af strukturer
- Indlejring af en struktur i en anden struktur giver mulighed for en form for arv i Go.
``` gå
type Person struct {
navnestreng
alder int
}
type Employee struct {
løn int
Person
}
```
- Her indlejrer `Employee` `Person`, så en `Employee`-variabel vil inkludere felterne fra `Person` (navn og alder) såvel som sine egne felter.
``` gå
emp :=Medarbejder{løn:100000, Person:Person{navn:"John", alder:30}}
fmt.Println(emp.løn) // 100000
fmt.Println(emp.name) // John
```
- Den indlejrede strukturs felter forfremmes til den ydre (indeholdende) struktur, som om de var erklæret i den indeholdende struktur. Her kan `navn` og `alder` felterne for `Person` nu tilgås på `Employee` variablen (`emp`).
Tags i strukturer
- Tags kan knyttes til strukturfelter for at give yderligere information. Disse tags bruges af refleksion og indkodere/dekodere.
``` gå
type Person struct {
navnestreng `json:"navn"` // json-tag
age int `xml:"age"` // xml tag
}
```
- Taggene er omgivet af backticks (‘`’), hvis de indeholder mellemrum eller andre specialtegn.
Konklusion
- Strukturer giver en måde at gruppere relaterede data sammen og oprette dine brugerdefinerede datatyper i Go.
- Navngivne og anonyme strukturer kan bruges alt efter situationen, og indlejring giver mulighed for en form for arv.
- Tags kan knyttes til strukturfelter for yderligere metadata og kompatibilitet med standardbiblioteker.
