Slices: die idiomatische Struktur

Ein Slice ist die am häufigsten verwendete Datenstruktur in Go: eine dynamische Ansicht über ein zugrunde liegendes Array. Syntax: []T. Im Gegensatz zu Arrays beträgt die Länge nicht Teil des Typs, und Sie können es mit append erweitern.

Anatomie einer Scheibe

Intern ist ein Slice eine Struktur mit drei Feldern:

– ein Zeiger auf das erste Element im zugrunde liegenden Array

• eine Länge (len): Anzahl der sichtbaren Elemente
• eine Kapazität (cap): Elemente, die ab dem Start der Ansicht verfügbar sind bis zum Ende des zugrunde liegenden Arrays

s := []int{10, 20, 30}
fmt.Println(len(s), cap(s)) // 3 3

Schöpfung

a := []int{1, 2, 3}          // literal
b := make([]int, 3)          // [0 0 0]   len=3 cap=3
c := make([]int, 3, 10)      // len=3 cap=10 (reserved)
var d []int                  // nil slice: len=0 cap=0, still usable with append

append: immer das Ergebnis zuweisen

append fügt Elemente hinzu und gibt einen neuen Slice zurück (möglicherweise Zuweisen eines neuen Arrays, wenn die Kapazität nicht ausreicht):

s := []int{1, 2, 3}
s = append(s, 4)              // [1 2 3 4]
s = append(s, 5, 6, 7)        // append multiple elements
s = append(s, altra...)       // concatenate another slice (spread)

Slice-Ausdruck s[a:b]

Extrahiert ein Sub-Slice von a (einschließlich) nach b (exklusiv):

s := []int{10, 20, 30, 40, 50}
sub := s[1:4]              // [20 30 40]
inizio := s[:2]            // [10 20]
fine := s[3:]              // [40 50]
intera := s[:]             // [10 20 30 40 50]

Unter-Slices teilen sich das zugrunde liegende Array mit dem Original-Slice: Mutationen durch sub[i] = ... sind auch in s sichtbar.

Fallstrick: Array-Freigabe

s := []int{1, 2, 3, 4}
sub := s[0:2]
sub[0] = 99
fmt.Println(s)             // [99 2 3 4] — modified!

Um eine unabhängige Kopie zu erhalten, verwenden Sie copy oder append:

out := make([]int, len(sub))
copy(out, sub)

Probieren Sie es aus

s := []int{1, 2, 3}
// (a) s = append(s, 4)
// (b) append(s, 4)

Zusammenfassung

• []T: dynamische Ansicht über ein Array; dreifach (ptr, len, cap).
• make([]T, len, cap) zur Vorabzuweisung; var s []T für ein nutzbares Null-Slice.
• s = append(s, ...): Das Ergebnis IMMER zuweisen. – s[a:b] teilt das zugrunde liegende Array: copy(...) für unabhängige Kopien.
• Ein nil-Slice = OK zum Lesen/Bereich/Anhängen; ganz anders als eine Nullkarte.