Modul 5: Slices & Maps unter der Haube
Slices & Maps in Go von innen verstehen: Slice-Header und Referenzsemantik, append-Wachstum und Aliasing, Map-Zugriffe und Concurrent Maps, Parameter- und nil-Semantik sowie idiomatische Filter/Map/Reduce-Muster.
Slices vs Arrays: len, cap & Referenzsemantik
Lektion 21 von 100
Arrays sind Werte, Slices sind Fenster
Stellen Sie sich vor, Sie übergeben einer Funktion ein Array mit 250.000 Sensorwerten vom Typ float64 — rund 2 MB Daten — und wundern sich, warum Ihr Memory-Profil plötzlich Speicherkopien überall zeigt. Der Grund ist ein Kernprinzip von Go: Ein Array ist ein Wert. Der Typ trägt seine feste Größe in sich ([4]int und [5]int sind zwei völlig verschiedene Typen), und jede Zuweisung kopiert das komplette Array.
Ein Slice ist dagegen nur ein kleiner Verweis auf ein dahinterliegendes Array — der sogenannte Slice-Header. Bei einer Zuweisung wird nur dieser Header kopiert, nicht die Daten. Deshalb verhalten sich Slices beim Elementzugriff wie Referenzen, obwohl auch bei ihnen der Wert semantisch kopiert wird.
Der Slice-Header
Ein Slice ist zur Laufzeit eine kleine Struktur aus drei Wörtern: ein Zeiger auf das erste Element des zugrunde liegenden Arrays, die Länge (len) und die Kapazität (cap). Weil Zuweisungen nur diesen Header kopieren, zeigen zwei Kopien auf dasselbe Array — deshalb wirkt ein Slice wie eine Referenz, ein Array dagegen wie ein Wert.
Der Unterschied lässt sich in wenigen Zeilen direkt beobachten:
package main
import "fmt"
func main() {
// Array: komplette Kopie bei der Zuweisung
a := [4]int{1, 2, 3, 4}
b := a
b[0] = 99
fmt.Println(a, b)
// → [1 2 3 4] [99 2 3 4]
// Slice: nur der Header wird kopiert, das Array bleibt geteilt
s := []int{1, 2, 3, 4}
t := s
t[0] = 99
fmt.Println(s, t)
// → [99 2 3 4] [99 2 3 4]
fmt.Println(len(s), cap(s))
// → 4 4
}
len, cap und das Reslicing
Bei einem Slice-Literal sind len und cap zunächst gleich. Interessant wird es beim Reslicing: Mit s[low:high] schneiden Sie ein Fenster aus dem bestehenden Slice — ohne auch nur ein Byte zu kopieren. Der neue Header zeigt mitten ins alte Array, len beschreibt die Fensterbreite und cap den verbleibenden Platz bis zum Ende des zugrunde liegenden Arrays.
s := make([]int, 3, 10) // len 3, cap 10
u := s[1:] // Fenster ab Index 1
fmt.Println(len(s), cap(s))
// → 3 10
fmt.Println(len(u), cap(u))
// → 2 9 — cap sinkt um die abgeschnittene Position
tail := s[2:]
tail[0] = 42 // schreibt ins selbe Array wie s
fmt.Println(s)
// → [0 0 42]
Diese geteilte Ansicht ist kein Bug, sondern ein Feature: Reslicing macht Funktionssignaturen wie process(data []byte) extrem billig, weil nie kopiert wird. Der Preis ist, dass Sie immer im Hinterkopf behalten müssen, wessen Speicher Sie da gerade verändern.
⚠ Häufiger Fehler: Wer aus JavaScript oder Python kommt, erwartet bei
b := amit einem Array eine Referenz wie bei einem Objekt — und wundert sich, warumb[0] = 99das Original nicht ändert. In Go ist ein Array ein Wert, und die Zuweisung kopiert jedes Element. Umgekehrt gilt für Slices: Sie teilen sich beim Elementzugriff dasselbe Array, auch wenn der Header kopiert wurde.
✅ Wichtige Erkenntnisse
Haken setzen, um deinen Lernfortschritt zu markieren:
append: Wachstum, Aliasing & die copy-Falle
Lektion 22 von 100
append sieht harmlos aus — und trifft unsichtbar Entscheidungen
append ist die meistgenutzte Funktion im Umgang mit Slices, und genau deshalb lohnt sich ein Blick unter die Haube. Jeder Aufruf muss entscheiden: Reicht die Kapazität, oder muss ein größeres Array allokiert und alles umkopiert werden? Das ist kein akademisches Detail — es bestimmt, ob zwei Slices weiterhin denselben Speicher teilen oder sich plötzlich trennen.
Der klassische Stolperfall aus der Praxis: Zwei Codepfade arbeiten über ein Reslice auf denselben Datenbestand. Einer hängt per append ein Element an — und weil die Kapazität noch reicht, landet dieses Element mitten im Datenbereich des anderen Slices. Kein Compilerfehler, kein Panic, nur leise verdrehte Daten.
Die Wachstumsstrategie
Ist cap erschöpft, allokiert die Runtime ein neues, größeres Array und kopiert die alten Elemente hinüber. Bei kleinen Slices verdoppelt Go die Kapazität typischerweise pro Schritt (1, 2, 4, 8, 16 ...). Wer die Zielgröße kennt, sollte von vornherein mit make([]T, 0, n) allozieren und sich so die Kopieraktionen sparen.
s := make([]int, 0)
prev := cap(s)
for i := 1; i <= 9; i++ {
s = append(s, i)
if cap(s) != prev {
fmt.Printf("len=%d cap=%d (neues Feld)\n", len(s), cap(s))
prev = cap(s)
}
}
// → len=1 cap=1 (neues Feld)
// → len=2 cap=2 (neues Feld)
// → len=3 cap=4 (neues Feld)
// → len=5 cap=8 (neues Feld)
// → len=9 cap=16 (neues Feld)
Aliasing: Wenn zwei Slices denselben Speicher sehen
Solange cap nicht erschöpft ist, schreibt append in das bestehende Array — und damit möglicherweise in Daten, die ein anderes Slice gerade dort liegen glaubt. Erst wenn die Kapazität reicht, bekommt das vergrößerte Slice ein eigenes neues Array, während das alte unverändert bleibt.
a := []int{1, 2, 3, 4, 5}
b := a[1:3] // len 2, teilt das Array mit a
b = append(b, 99) // cap reicht noch: landet in a[3]
fmt.Println(a)
// → [1 2 3 99 5]
fmt.Println(b)
// → [2 3 99]
Der Ausweg ist der volle Slice-Ausdruck s[low:high:max], der die Kapazität des Fensters gezielt begrenzt:
a := []int{1, 2, 3, 4, 5}
b := a[1:3:3] // cap bewusst auf 3 begrenzt
b = append(b, 99) // zwingt eine neue Allokation
fmt.Println(a)
// → [1 2 3 4 5] — a bleibt unangetastet
fmt.Println(b)
// → [2 3 99]
Und die copy-Falle: copy(dst, src) überträgt nur so viele Elemente wie in das kleinere der beiden Slices passen — bei einem leeren oder nil-Ziel also genau null, ohne jede Fehlermeldung:
src := []int{1, 2, 3, 4, 5}
dst := make([]int, 3) // ohne make (dst := []int{}) wäre n == 0
n := copy(dst, src)
fmt.Println(n, dst)
// → 3 [1 2 3]
⚠ Häufiger Fehler: Ein
appendauf ein Reslice kann stillschweigend Daten des Nachbarslices überschreiben, solange die Kapazität des gemeinsamen Arrays reicht. Wer mits[low:high]ein Fenster weitergibt und der Gegenseite erlaubt anzuhängen, sollte entweder den vollen Slice-Ausdrucks[low:high:max]nutzen oder vor dem Anhängen eine echte Kopie anlegen.
✅ Wichtige Erkenntnisse
Haken setzen, um deinen Lernfortschritt zu markieren:
Maps: Semantik, fehlende Keys & Concurrent Maps
Lektion 23 von 100
Die stille Map: fehlende Keys liefern niemals einen Fehler
Maps in Go sind Verweissemantik pur: Die Zuweisung m2 := m1 kopiert keinen einzigen Eintrag, beide Variablen zeigen auf dieselbe Hashmap im Speicher. Und ein zentrales Verhaltensmerkmal sorgt regelmäßig für Überraschungen: Ein Zugriff auf einen fehlenden Key panict nicht, sondern liefert stillschweigend den Nullwert des Werttyps.
Das Szenario aus dem Alltag: Eine Konfigurationsmap hält Ports nach Dienstnamen, ein Tippfehler im Key ("apiGateway" statt "api-gateway") bleibt unbemerkt, und das Programm läuft weiter — mit Port 0. Genau dafür gibt es das comma-ok-Idiom, das die Existenzprüfung zum Einzeiler macht.
Das comma-ok-Idiom
Der Zwei-Wert-Zugriff v, ok := m[key] trennt zwei Fälle, die Go sonst nicht unterscheiden kann: Der Key fehlt (ok == false, v ist der Nullwert) oder er existiert und sein Wert ist zufällig der Nullwert. Nur mit ok wissen Sie sicher, ob der Eintrag wirklich da war — delete hingegen meldet fehlende Keys niemals als Fehler.
m := map[string]int{"go": 2009, "rust": 2010}
jahr, ok := m["python"]
fmt.Println(jahr, ok)
// → 0 false
m["python"] = 1991
jahr, ok = m["python"]
fmt.Println(jahr, ok)
// → 1991 true
delete(m, "cobol") // Key war nie vorhanden — kein Fehler
fmt.Println(len(m))
// → 3
for k := range m {
fmt.Println(k)
}
// → go, rust, python — Reihenfolge absichtlich zufällig
Concurrent Maps: die nicht abfangbare Panik
Die builtin Map ist absichtlich nicht nebenläufigkeitssicher: Sobald zwei Goroutines gleichzeitig schreiben — oder einer schreibt, während ein anderer liest — bricht die Runtime mit fatal error: concurrent map writes ab. Das ist kein gewöhnlicher Panic: Ein recover in einer anderen Goroutine kann Sie nicht retten, der Prozess ist weg. Der Race-Detector (go test -race) findet solche Stellen zuverlässig, bevor es passiert.
Die Standardlösung ist ein sync.Mutex um jeden Zugriff. Für reine Zähler- oder Cache-Szenarien mit hoher Leselast ist auch sync.Map einen Blick wert — in den meisten Fällen ist aber Mutex plus normale Map die klarere Wahl.
var counter = make(map[string]int)
var mu sync.Mutex
func incr(worker string) {
for i := 0; i < 1000; i++ {
mu.Lock()
counter[worker]++
mu.Unlock()
}
}
func main() {
var wg sync.WaitGroup
for _, w := range []string{"a", "b", "c"} {
wg.Add(1)
go func(name string) {
defer wg.Done()
incr(name)
}(w)
}
wg.Wait()
fmt.Println(counter["a"], counter["b"], counter["c"])
// → 1000 1000 1000
}
Ohne den Mutex würde dieses Programm mit hoher Wahrscheinlichkeit mit fatal error: concurrent map writes sterben — und zwar nicht deterministisch, sondern genau dann, wenn es in Produktion am meisten Last sieht.
⚠ Häufiger Fehler: Ein nil-Map beschreiben zu wollen — etwa nach
var m map[string]intdirekt mitm["x"] = 1— löst die Panikassignment to entry in nil mapaus. Lesen aus einem nil-Map ist dagegen völlig legal und liefert den Nullwert. Erstmake(map[string]int)oder ein Literal macht das Map schreibbar.
✅ Wichtige Erkenntnisse
Haken setzen, um deinen Lernfortschritt zu markieren:
Slices/Maps als Funktionsparameter & nil-Semantik
Lektion 24 von 100
„Warum hat meine Funktion mein Slice nicht verlängert?"
Diese Debugging-Session kennt jeder Go-Entwickler: Eine Funktion hängt per append an den Parameter an, und beim Aufrufer ist nichts passiert. Die Erklärung folgt direkt aus Lektion 21: Parameter werden per Wert übergeben — bei einem Slice also der Header. Die Funktion erhält eine Kopie von Zeiger, len und cap. Schreibt sie innerhalb der bestehenden Länge in das Array, sieht das der Aufrufer. Verlängert sie das Slice, wächst nur ihre lokale Kopie des Headers — bei vollem Array wird sogar ein komplett neues allokiert, das nur sie kennt.
func nullen(s []int) {
for i := range s {
s[i] = 0
}
}
func verlaengereKaputt(s []int) {
s = append(s, 99) // ändert nur den lokalen Header
}
nums := []int{1, 2, 3}
nullen(nums)
fmt.Println(nums)
// → [0 0 0] — Schreiben in bestehende Elemente ist sichtbar
verlaengereKaputt(nums)
fmt.Println(nums)
// → [0 0 0] — das angehängte Element existiert nur lokal
nums = append(nums, 99)
fmt.Println(nums)
// → [0 0 0 99]
Bei Maps ist der Effekt anders verteilt: Der Parameter ist ebenfalls ein kleiner Verweis, und Einfügeoperationen sind für den Aufrufer sichtbar. Unsichtbar bleibt nur eine komplette Neubindung des Parameters:
func registriere(m map[string]bool) {
m["gast"] = true // sichtbar für den Aufrufer
m = map[string]bool{} // lokale Neubindung
m["phantom"] = true // landet nur in der lokalen Map
}
besucher := map[string]bool{"admin": true}
registriere(besucher)
fmt.Println(besucher)
// → map[admin:true gast:true]
Die Faustregel: Umlenken macht sichtbar, Verlängern nicht
Änderungen an bestehenden Elementen eines Slice-Parameters und neue Einträge in einen Map-Parameter sind für den Aufrufer sichtbar, weil beide denselben Speicher nutzen. Alles, was len eines Slices verändert (append, Reslice-Header), bleibt lokal — der idiomatiche Ausweg ist, das Slice zurückzugeben: s = append(s, x) vom Rückgabewert.
nil-Semantik: leeres Slice, nil-Slice, nil-Map
Ein deklariertes, aber nicht initialisiertes Slice ist nil — kein Panic-Wert, sondern ein ganz normaler Zustand. len, cap, range und append funktionieren darauf alle problemlos. Ein nil-Map kann gelesen werden (Nullwert), aber nicht beschrieben werden. Wo der Unterschied wirklich wehtut, ist die JSON-Serialisierung:
var nilSlice []int
leer := []int{}
fmt.Println(nilSlice == nil, leer == nil, len(nilSlice), len(leer))
// → true false 0 0
nilSlice = append(nilSlice, 1)
fmt.Println(nilSlice)
// → [1] — append auf nil ist der Normalfall
var nilMap map[string]int
fmt.Println(nilMap["x"])
// → 0 — Lesen aus einem nil-Map ist erlaubt
// nilMap["x"] = 1 wäre: panic: assignment to entry in nil map
type User struct {
Tags []string `json:"tags"`
}
b1, _ := json.Marshal(User{})
b2, _ := json.Marshal(User{Tags: []string{}})
fmt.Println(string(b1))
// → {"tags":null}
fmt.Println(string(b2))
// → {"tags":[]}
API-Consumer, die Felder als Arrays erwarten, brechen an null gerne auseinander — deshalb initialisiert man Slice-Felder in Response-Structs konsequent mit []T{} statt sie nil zu lassen.
⚠ Häufiger Fehler: Man erwartet, dass ein
appendinnerhalb der Funktion beim Aufrufer ankommt, weil „Slices doch Referenzen sind". Tatsächlich wurde nur der lokale Header verlängert; der Aufrufer behält seine altelen. Die Funktion muss das Slice zurückgeben, und der Aufrufer muss das Ergebnis zuweisen —s = append(s, ...)an der Aufrufstelle.
✅ Wichtige Erkenntnisse
Haken setzen, um deinen Lernfortschritt zu markieren:
Muster: Filter/Map/Reduce idiomatisch in Go
Lektion 25 von 100
Kein Stream-API? Doch — aber in Go-Art
Wer aus Java (Streams) oder JavaScript (.filter().map()) kommt, vermisst in Go zunächst die funktionalen Helfer. Der idiomatiche Go-Weg ist erstaunlich schlicht: eine explizite for-Schleife mit range. Sie ist lesbar, ohne Magie und vom Compiler gut optimierbar. Seit Generics (Go 1.18) und dem Paket slices (Go 1.21) lassen sich wiederkehrende Muster aber auch als kleine, typsichere Helfer ausdrücken — ohne das interface{}-Gefrickel früherer Jahre.
Die Regel aus der Praxis: Ein einzelnes Filter oder Map als generischer Helfer ist fein. Fünfstufige Verkettungsketten wie in Java erzwingen in Go nur Unlesbarkeit — da sind drei klare Schleifen mit gut benannten Zwischenvariablen ehrlicher.
Generics machen die Helfer typsicher
func Filter[T any](s []T, keep func(T) bool) []T behält den Elementtyp bei, ohne Reflection oder Typ-Assertions. Kombiniert man die Helfer, entsteht eine Pipeline; Go wertet dabei jeden Schritt als eigene Schleife über ein eigenes Ergebnis-Slice — träge Auswertung wie bei Java-Streams gibt es nicht.
func Filter[T any](s []T, keep func(T) bool) []T {
out := make([]T, 0, len(s))
for _, v := range s {
if keep(v) {
out = append(out, v)
}
}
return out
}
func Map[T, U any](s []T, f func(T) U) []U {
out := make([]U, 0, len(s))
for _, v := range s {
out = append(out, f(v))
}
return out
}
preise := []int{199, 45, 1200, 89}
unter500 := Filter(preise, func(p int) bool { return p < 500 })
fmt.Println(unter500)
// → [199 45 89]
labels := Map(unter500, func(p int) string {
return fmt.Sprintf("%.2f EUR", float64(p)/100)
})
fmt.Println(labels)
// → [1.99 EUR 0.45 EUR 0.89 EUR]
Reduce und die Standardbibliothek
Reduce folgt demselben Muster: ein Akkumulator, der Zeile für Zeile durchlaufen wird. Wichtig ist die bewusste Wahl des Startwerts — bei einem leeren Slice ist das Ergebnis exakt dieser Startwert, niemals eine Panik:
func Reduce[T, U any](s []T, init U, combine func(U, T) U) U {
acc := init
for _, v := range s {
acc = combine(acc, v)
}
return acc
}
type Bestellung struct {
Kunde string
Betrag float64
}
bestellungen := []Bestellung{
{"Ada", 120.50},
{"Lin", 79.99},
{"Grace", 45.00},
}
summe := Reduce(bestellungen, 0.0, func(acc float64, b Bestellung) float64 {
return acc + b.Betrag
})
fmt.Printf("Gesamt: %.2f EUR\n", summe)
// → Gesamt: 245.49 EUR
Bevor Sie eigene Helfer schreiben, prüfen Sie das Paket slices — Sortieren, Suchen und Vergleichen sind schon da:
import "slices"
namen := []string{"kiwi", "apfel", "banane"}
slices.Sort(namen)
fmt.Println(namen)
// → [apfel banane kiwi]
idx, ok := slices.BinarySearch(namen, "banane")
fmt.Println(idx, ok)
// → 1 true
Und die Falle, die in jede Filter- oder Reduce-Implementierung eingebaut werden will: range liefert bei Slices nur eine Kopie des Elements. Wer die Kopie verändert, ändert die Daten im Slice nicht:
type Kunde struct {
Name string
Umsatz float64
}
kunden := []Kunde{{"Ada", 0}, {"Lin", 0}}
for _, k := range kunden {
k.Umsatz = 100 // ändert nur die Kopie im Loop
}
fmt.Println(kunden)
// → [{Ada 0} {Lin 0}]
for i := range kunden {
kunden[i].Umsatz = 100 // über den Index: wirklich geändert
}
fmt.Println(kunden)
// → [{Ada 100} {Lin 100}]
⚠ Häufiger Fehler: In
for _, v := range kundenistveine Kopie des Elements — Felder aufvzu setzen, ändert die Daten im Slice nicht. Wer Elemente verändern will, greift über den Index zu (kunden[i].Umsatz = 100) oder arbeitet mit einem Slice von Zeigern.
✅ Wichtige Erkenntnisse
Haken setzen, um deinen Lernfortschritt zu markieren: