Wie arbeitet man mit Slices in Go?

Slices in Go sind keine Arrays, sondern verweisen auf einen Abschnitt (oder das gesamte) des Basiselements. Es sind dynamische Datenstrukturen.

Erstellung von Slices:

• Aus einem Array:

// Array definieren
arr := [5]int{1, 2, 3, 4, 5}
// Slice aus einem Teil des Arrays erstellen
s1 := arr[1:4] // s1 enthält die Elemente arr[1], arr[2], arr[3]
// Ein weiteres Slice erstellen
s2 := arr[:3]  // s2 enthält die Elemente arr[0], arr[1], arr[2]
// Ein Slice, das auf das gesamte Array zeigt
s3 := arr[2:]  // s3 enthält die Elemente arr[2], arr[3], arr[4]
// Ein Slice, das auf das gesamte Array zeigt
s4 := arr[:]

• Mit make:

// Erstellen eines Slices mit Länge 5 und Kapazität 5
s := make([]int, 5)
// Erstellen eines Slices mit Länge 5 und Kapazität 10
s_cap := make([]int, 5, 10)

• Literal:

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

Hauptmerkmale des Slices:

• len(s): gibt die aktuelle Länge des Slices zurück.
• cap(s): gibt die Kapazität des Slices zurück (maximale Anzahl an Elementen, die vor einer Reallokation enthalten sein können).

Hinzufügen von Elementen (append):

s := []int{1, 2}
s = append(s, 3)      // fügt ein Element hinzu
s = append(s, 4, 5)   // fügt mehrere Elemente hinzu
s2 := []int{6, 7}
s = append(s, s2...) // fügt die Elemente eines anderen Slices hinzu

append kann eine Reallokation des Basiselements auslösen, wenn die Kapazität nicht ausreicht.

Entfernen von Elementen:

Das Entfernen von Elementen aus einem Slice erfolgt durch Erstellen eines neuen Slices mit den verbleibenden Elementen oder durch Kopieren.

s := []int{1, 2, 3, 4, 5}
// Element bei Index i entfernen
i := 2 // entfernt das Element bei Index 2 (also 3)
s = append(s[:i], s[i+1:]...)

Kopieren von Slices:

src := []int{1, 2, 3}
dst := make([]int, len(src))
copy(dst, src) // kopiert die Elemente von src nach dst

copy kopiert das Minimum der Längen der beiden Slices.

Iteration über einen Slice:

s := []string{"a", "b", "c"}
for i, v := range s {
    // i ist der Index, v ist der Wert
}
for i := range s {
    // nur der Index
}
for _, v := range s {
    // nur der Wert
}

Slices sind Referenztypen:

Änderungen an einem Slice spiegeln sich im Basiselement und in anderen Slices wider, die auf denselben Speicher verweisen.

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
// Jetzt arr: [1, 99, 3, 4, 5]
// s1: [99, 3, 4]
// s2: [3, 4, 5] (das Element arr[2] hat sich geändert)