- Golang-structuren stellen ons in staat gegevens te groeperen.

- Ze zijn vergelijkbaar met structuren in andere programmeertalen.

- Structuren zijn door de gebruiker gedefinieerde gegevenstypen, waarmee u uw eigen aangepaste typen kunt maken.

- Structuren kunnen elk type gegevens bevatten, inclusief andere structuren.

Structuurdefinitie:

```gaan

type structuurnaam struct {

lid_naam type1

lid_naam type2

...

lid_naam typeN

}

```

- Dit definieert een structuur genaamd `structure_name` met leden `member_name`. Elk lid heeft een type, dat elk geldig Go-type kan zijn.

Structures creëren:

```gaan

var structuurnaam =structuurtype {

lid_naam1:waarde1,

lid_naam2:waarde2,

...

lid_naamN:waardeN

}

```

- Dit creëert een variabele van het type `structuurnaam` en initialiseert zijn leden met de gegeven waarden.

Toegang tot leden:

- Om toegang te krijgen tot een structuurlid, gebruikt u de puntoperator:`structuur_naam.lid_naam`.

Voorbeeld:

```gaan

// Definieer een structuur met de naam persoon met naam en leeftijdsleden.

type persoonsstructuur {

Naamreeks

Leeftijd int

}

func hoofd() {

// Maak een persoon met de naam "John Doe".

persoon1 :=persoon{"John Doe", 30}

// Druk de naam en leeftijd van John af.

fmt.Println("Naam:", persoon1.Naam)

fmt.Println("Leeftijd:", persoon1.Leeftijd)

}

```

Genoemde structuren:

- Als een structuur velden met basisgegevenstypen bevat, kan deze worden gedeclareerd zonder een struct-trefwoord.

```gaan

typ MyStruct-structuur {

een int

b vlotter32

c-reeks

}

typ uw structuur {

f int 'json:"eerste"'

l-tekenreeks 'json:"laatste"'

}

```

- Voor zowel `MyStruct` als `uw struct` hierboven is het sleutelwoord struct optioneel

Anonieme structuren

- Anonieme structuren kunnen worden gebruikt om ad-hocgegevenstypen te maken zonder expliciet een struct-type te definiëren.

- Wanneer een anonieme structuur wordt gebruikt als veld van een andere structuur of als element van een segment/kaart, is het veldtype de anonieme structuur en de tag van het veld de typenaam.

```gaan

type Persoonsstructuur {

naamreeks

leeftijd int

}

```

- Als alternatief kunnen anonieme structuren worden gebruikt om een ​​structuur te instantiëren zonder een struct-type te definiëren.

```gaan

var persoon =struct {

naamreeks

leeftijd int

}{naam:"Bob", leeftijd:20}

```

- In dit geval de variabele persoon van het type `struct{ naamstring; age int }` wordt gemaakt en geïnitialiseerd.

Structures inbedden

- Het inbedden van een struct in een andere struct maakt een vorm van overerving in Go mogelijk.

```gaan

type Persoonsstructuur {

naamreeks

leeftijd int

}

type Werknemerstructuur {

salaris int

Persoon

}

```

- Hier sluit 'Werknemer' 'Persoon' in, zodat een variabele 'Werknemer' zowel de velden van 'Persoon' (naam en leeftijd) als zijn eigen velden zal bevatten.

```gaan

emp :=Werknemer{salaris:100000, Persoon:Persoon{naam:"John", leeftijd:30}}

fmt.Println(werk.salaris) // 100000

fmt.Println(emp.naam) // John

```

- De velden van de ingebedde struct worden gepromoveerd naar de buitenste (bevattende) struct alsof ze in de bevattende struct zijn gedeclareerd. Hier zijn de velden 'naam' en 'leeftijd' van 'Persoon' nu toegankelijk via de variabele 'Werknemer' ('emp').

Tags in structuren

- Tags kunnen aan structuurvelden worden toegevoegd om aanvullende informatie te verschaffen. Deze tags worden gebruikt door reflectie- en encoders/decoders.

```gaan

type Persoonsstructuur {

naamreeks `json:"naam"` // json-tag

age int `xml:"age"` // xml-tag

}

```

- De tags worden omsloten door backticks (‘`’) als ze spaties of andere speciale tekens bevatten.

Conclusie

- Structuren bieden een manier om gerelateerde gegevens te groeperen en uw aangepaste gegevenstypen in Go te maken.

- Afhankelijk van de situatie kunnen benoemde en anonieme structuren worden gebruikt, waarbij inbedding een vorm van overerving mogelijk maakt.

- Tags kunnen worden toegevoegd aan structuurvelden voor extra metadata en compatibiliteit met standaardbibliotheken.