Hoe werk je met slices in Go?

Slices in Go zijn geen arrays, maar verwijzen naar een segment (of het hele) van de basismatrix. Het zijn dynamische gegevensstructuren.

Aanmaken van slices:

• Vanuit een array:

// een array definiëren
arr := [5]int{1, 2, 3, 4, 5}
// een slice maken van een deel van de array
s1 := arr[1:4] // s1 bevat de elementen arr[1], arr[2], arr[3]
// een andere slice maken
s2 := arr[:3]  // s2 bevat de elementen arr[0], arr[1], arr[2]
// een slice die naar de hele array verwijst
s3 := arr[2:]  // s3 bevat de elementen arr[2], arr[3], arr[4]
// een slice die naar de hele array verwijst
s4 := arr[:]

• Met make:

// Een slice maken met lengte 5 en capaciteit 5
s := make([]int, 5)
// Een slice maken met lengte 5 en capaciteit 10
s_cap := make([]int, 5, 10)

• Literale notatie:

s := []int{1, 2, 3}

Belangrijkste eigenschappen van slices:

• len(s): geeft de huidige lengte van de slice.
• cap(s): geeft de capaciteit van de slice (het maximale aantal elementen dat erin kan voordat er een reallocatie plaatsvindt).

Elementen toevoegen (append):

s := []int{1, 2}
s = append(s, 3)      // voegt één element toe
s = append(s, 4, 5)   // voegt meerdere elementen toe
s2 := []int{6, 7}
s = append(s, s2...) // voegt de elementen van een andere slice toe

append kan een reallocatie van de basismatrix veroorzaken als de capaciteit niet voldoende is.

Elementen verwijderen:

Verwijderen van elementen uit een slice wordt gedaan door een nieuwe slice te maken met de overgebleven elementen of door te kopiëren.

s := []int{1, 2, 3, 4, 5}
// Verwijder het element op index i
i := 2 // verwijdert het element op index 2 (namelijk 3)
s = append(s[:i], s[i+1:]...)

Slices kopiëren:

src := []int{1, 2, 3}
dst := make([]int, len(src))
copy(dst, src) // kopieert de elementen van src naar dst

copy kopieert de minimale lengte van de twee slices.

Itereren over een slice:

s := []string{"a", "b", "c"}
for i, v := range s {
    // i - index, v - waarde
}
for i := range s {
    // alleen index
}
for _, v := range s {
    // alleen waarde
}

Slices zijn referentietypes:

Wijzigingen in een slice worden weerspiegeld in de basismatrix en andere slices die naar dezelfde geheugenruimte verwijzen.

arr := [5]int{1, 2, 3, 4, 5}
s1 := arr[1:4] // [2, 3, 4]
s2 := arr[2:5] // [3, 4, 5]

s1[0] = 99
// Nu arr: [1, 99, 3, 4, 5]
// s1: [99, 3, 4]
// s2: [3, 4, 5] (het element arr[2] is gewijzigd)