## Strukturer
– Golang-strukturer gör att vi kan gruppera data tillsammans.
– De liknar strukturer i andra programmeringsspråk.
- Strukturer är användardefinierade datatyper och de låter dig skapa dina egna anpassade typer.
- Strukturer kan innehålla vilken typ av data som helst, inklusive andra strukturer.
Strukturdefinition:
``` gå
typ strukturnamn struct {
medlemsnamn typ1
medlemsnamn typ2
...
medlemsnamn typN
}
```
- Detta definierar en struktur som heter `strukturnamn` med medlemmarna `medlemsnamn`. Varje medlem har en typ, som kan vara vilken som helst giltig Go-typ.
Skapa strukturer:
```gå
var strukturnamn =strukturtyp {
medlemsnamn1:värde1,
medlemsnamn2:värde2,
...
medlemsnamnN:värdeN
}
```
- Detta skapar en variabel av typen `structure_name` och initierar dess medlemmar med de givna värdena.
Åtkomst till medlemmar:
- För att komma åt en strukturmedlem, använd punktoperatorn:`strukturnamn.medlemsnamn`.
Exempel:
```gå
// Definiera en struktur med namnet person med namn och åldersmedlemmar.
typ person struct {
Namnsträng
Ålder int
}
func main() {
// Skapa en person som heter "John Doe".
person1 :=person{"John Doe", 30}
// Skriv ut Johns namn och ålder.
fmt.Println("Namn:", person1.Namn)
fmt.Println("Ålder:", person1.Ålder)
}
```
Namngivna strukturer:
- Om en struktur innehåller fält med grundläggande datatyper kan den deklareras utan ett struct-nyckelord.
``` gå
typ MyStruct struct {
en int
b flyta32
c sträng
}
skriv din struct {
f int 'json:"först"'
l sträng 'json:"last"'
}
```
- För både "MyStruct" och "din struktur" ovan är nyckelordet struct valfritt
Anonyma strukturer
- Anonyma strukturer kan användas för att skapa ad-hoc datatyper utan att explicit definiera en strukturtyp.
- När en anonym struktur används som ett fält i en annan struktur eller som ett element i en skiva/karta, är fältets typ den anonyma strukturen och fältets tagg är typnamnet.
```gå
typ Person struct {
namnsträng
ålder int
}
```
- Alternativt kan anonyma strukturer användas för att instansiera en struktur utan att definiera en strukturtyp.
```gå
var person =struct {
namnsträng
ålder int
}{namn:"Bob", ålder:20}
```
- I det här fallet, variabeln person av typen `struct{ namnsträng; age int }` skapas och initieras.
Inbäddningsstrukturer
- Att bädda in en struktur i en annan struktur möjliggör en form av arv i Go.
``` gå
typ Person struct {
namnsträng
ålder int
}
typ Employee struct {
lön int
Person
}
```
- Här bäddar `Employee` in `Person` så en `Employee`-variabel kommer att inkludera fälten från `Person` (namn och ålder) såväl som sina egna fält.
```gå
emp :=Anställd{lön:100000, Person:Person{namn:"John", ålder:30}}
fmt.Println(emp.lön) // 100 000
fmt.Println(emp.namn) // John
```
- Den inbäddade strukturens fält flyttas upp till den yttre (innehållande) strukturen som om de deklarerades i den innehållande strukturen. Här kan nu `namn` och `ålder`-fälten för `Person` nås på `Employee`-variabeln (`emp`).
Taggar i strukturer
- Taggar kan kopplas till strukturfält för att ge ytterligare information. Dessa taggar används av reflektion och kodare/avkodare.
``` gå
typ Person struct {
namnsträng `json:"namn"` // json-tagg
age int `xml:"age"` // xml-tagg
}
```
- Taggarna är inneslutna i backticks (‘`’) om de innehåller mellanslag eller andra specialtecken.
Slutsats
- Strukturer ger ett sätt att gruppera relaterade data tillsammans och skapa dina anpassade datatyper i Go.
– Namngivna och anonyma strukturer kan användas beroende på situation, och inbäddning möjliggör en form av arv.
- Taggar kan kopplas till strukturfält för ytterligare metadata och kompatibilitet med standardbibliotek.
