Skip to content

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.

Fortschritt0/5 Lektionen
21

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 := a mit einem Array eine Referenz wie bei einem Objekt — und wundert sich, warum b[0] = 99 das 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:

    22

    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 append auf ein Reslice kann stillschweigend Daten des Nachbarslices überschreiben, solange die Kapazität des gemeinsamen Arrays reicht. Wer mit s[low:high] ein Fenster weitergibt und der Gegenseite erlaubt anzuhängen, sollte entweder den vollen Slice-Ausdruck s[low:high:max] nutzen oder vor dem Anhängen eine echte Kopie anlegen.

    ✅ Wichtige Erkenntnisse

    Haken setzen, um deinen Lernfortschritt zu markieren:

      23

      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]int direkt mit m["x"] = 1 — löst die Panik assignment to entry in nil map aus. Lesen aus einem nil-Map ist dagegen völlig legal und liefert den Nullwert. Erst make(map[string]int) oder ein Literal macht das Map schreibbar.

      ✅ Wichtige Erkenntnisse

      Haken setzen, um deinen Lernfortschritt zu markieren:

        24

        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 append innerhalb der Funktion beim Aufrufer ankommt, weil „Slices doch Referenzen sind". Tatsächlich wurde nur der lokale Header verlängert; der Aufrufer behält seine alte len. 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:

          25

          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 kunden ist v eine Kopie des Elements — Felder auf v zu 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:

            This site uses essential cookies for Stripe payments. No tracking cookies.