Hoe werken slices in Go?

Een slice is een lichte omhulling bovenop een array. Het slaat zelf geen gegevens op, maar verwijst naar een basarray.

Structuur van een slice:

• Pointer naar de basarray: Adres van het eerste element van de slice in het geheugen.
• Lengte (Length): Aantal elementen in de slice.
• Capaciteit (Capacity): Aantal elementen in de basarray, beschikbaar vanaf de pointer van de slice.

// Voorbeeld van het declareren van een slice
var s []int
s = append(s, 1, 2, 3) // Elementen toevoegen

// Interne voorstelling van s (vereenvoudigd)
// struct SliceHeader {
//     Data uintptr // Pointer naar de basarray
//     Len int      // Lengte van de slice
//     Cap int      // Capaciteit van de slice
// }

• Bij het maken van een slice met make([]T, length, capacity) wordt een basarray met de opgegeven capaciteit gemaakt, en een slice die hiernaar verwijst met de opgegeven lengte.
• Bij gebruik van een segment op een array of een andere slice (bijvoorbeeld arr[low:high:max]) wordt een nieuwe slice gemaakt die naar hetzelfde geheugengebied verwijst, maar met andere pointers, lengte en capaciteit.
• De operatie append kan leiden tot een geheugenherallocatie. Als de huidige capaciteit niet voldoende is om nieuwe elementen toe te voegen, maakt Go een nieuwe, grotere basarray, kopieert de oude elementen en wijzigt de pointer van de slice naar de nieuwe array. Dit wordt realloctatie genoemd. De groei van capaciteit bij append is exponentieel (verdubbelt tot een bepaalde grootte, daarna vertraagt het groei).
• Slices worden per waarde doorgegeven, maar omdat ze een pointer naar de basarray bevatten, zijn wijzigingen aan de elementen (via index) zichtbaar in alle slices die naar dezelfde array verwijzen.
• Het wijzigen van de lengte van een slice via een segment beïnvloedt de basarray niet, maar kan de toegang tot delen van de gegevens beperken.

Tabel: Vergelijking Length en Capacity

Kenmerk	Length	Capacity
Definitie	Werkelijke aantal elementen in de slice	Maximale aantal elementen dat de slice kan bevatten zonder herallocatie
Toegang	Wordt gebruikt om toegang te krijgen tot elementen (s[i])	Bepaalt hoeveel extra elementen kunnen worden toegevoegd met append voordat herallocatie plaatsvindt
Verkrijging	len(s)	cap(s)

// Voorbeeld van werken met capaciteit en lengte
s := make([]int, 0, 5) // Lengte 0, capaciteit 5
fmt.Println(len(s), cap(s)) // 0 5

s = append(s, 1, 2) // Twee elementen toevoegen
fmt.Println(len(s), cap(s)) // 2 5

s = append(s, 3, 4, 5, 6) // Nog 4 elementen toevoegen, vereist herallocatie
fmt.Println(len(s), cap(s)) // 6 10 (capaciteit is toegenomen)