Golang Slice: append, make, len vs cap und der Sharing-Bug

Ein Slice in einem Beispiel

Ein Slice ist eine wachsende Sicht auf ein Array. Du erzeugst einen mit einem Literal oder mit make, lässt ihn mit append wachsen und liest seine Größe mit len.

package main

import "fmt"

func main() {
	langs := []string{"Go", "Rust"}
	langs = append(langs, "Zig", "C")
	fmt.Println(langs, len(langs))

	for i, l := range langs {
		fmt.Println(i, l)
	}

	fmt.Println(langs[1:3]) // elements 1 and 2
}

[]string hat keine Länge in den Klammern. Das ist der Unterschied zu einem Array-Typ wie [4]string, dessen Größe feststeht.

Was ein Slice ist

Ein Slice-Wert ist ein kleiner Header mit drei Feldern:

• einem Pointer auf ein Element in einem Backing-Array
• einer Länge: wie viele Elemente der Slice sehen kann
• einer Kapazität: wie viele Elemente von diesem Pointer bis zum Ende des Backing-Arrays existieren

Einen Slice zu kopieren (zuweisen, an eine Funktion übergeben) kopiert nur diesen Header. Beide Kopien zeigen auf dieselben Elemente. Fast jede Überraschung mit Slices kommt daher, dass man das vergisst.

make: Länge und Kapazität

make([]T, len, cap) legt ein Backing-Array an und gibt einen Slice darüber zurück. Die Kapazität ist optional und entspricht standardmäßig der Länge.

package main

import "fmt"

func main() {
	a := make([]int, 3) // len 3, cap 3, all zeros
	fmt.Println(a, len(a), cap(a))

	b := make([]int, 0, 10) // len 0, room for 10
	fmt.Println(b, len(b), cap(b))

	for i := range 5 {
		b = append(b, i*i)
	}
	fmt.Println(b, len(b), cap(b)) // no reallocation happened
}

Eine häufige Verwechslung: make([]int, 5) gefolgt von fünf Aufrufen von append ergibt zehn Elemente, die ersten fünf davon null. Nimm make([]int, 0, 5), wenn du anhängen willst, oder make([]int, 5), wenn du per Index zuweisen willst.

Kapazität vorab zu reservieren, wenn du die endgültige Größe kennst, vermeidet wiederholtes Wachsen. Das ist eine Optimierung, keine Pflicht.

append und Wachstum

append fügt Elemente hinter der aktuellen Länge an. Reicht die Kapazität, schreibt es direkt hinein. Wenn nicht, legt es ein größeres Array an, kopiert die alten Elemente hinüber und gibt einen Slice zurück, der auf das neue Array zeigt.

package main

import "fmt"

func main() {
	var s []int
	prevCap := cap(s)
	for i := range 2000 {
		s = append(s, i)
		if cap(s) != prevCap {
			fmt.Printf("len %4d  cap %4d\n", len(s), cap(s))
			prevCap = cap(s)
		}
	}
}

Die Kapazität verdoppelt sich ungefähr, solange der Slice klein ist, und wächst ab 256 Elementen um einen kleineren Faktor (in Richtung 1,25x). Die genauen Zahlen sind ein Detail der Runtime, das sich zwischen Go-Versionen geändert hat, also schreib nie Code, der davon abhängt.

Weil append ein anderes Array zurückgeben kann, musst du sein Ergebnis verwenden:

append(s, 4)     // compile error: append(s, 4) (value of type []int) is not used
s = append(s, 4) // correct

Einen ganzen Slice hängst du mit der Spread-Syntax an: s = append(s, other...).

Slicing teilt das Backing-Array

s[low:high] erzeugt einen neuen Slice-Header über demselben Array, der die Indizes von low bis ausschließlich high abdeckt. Jede Grenze kann weggelassen werden. Es werden keine Elemente kopiert.

package main

import "fmt"

func main() {
	nums := []int{10, 20, 30, 40, 50}
	mid := nums[1:4] // 20 30 40
	mid[0] = 99
	fmt.Println(nums) // the write shows up in nums

	fmt.Println(len(mid), cap(mid)) // cap runs to the end of nums
}

Ausgabe:

[10 99 30 40 50]
3 4

Dieses Teilen macht Slicing billig. Es ist aber auch die Quelle des berühmtesten Slice-Bugs.

Der Aliasing-Bug bei append

Hat ein Teil-Slice freie Kapazität, schreibt ein append darauf in das Array des Eltern-Slices, über Elemente, die der Eltern-Slice noch benutzt.

package main

import "fmt"

func main() {
	base := []int{1, 2, 3, 4, 5}
	first := base[:2] // [1 2], cap 5

	first = append(first, 100) // fits in capacity: overwrites base[2]
	fmt.Println(base)
	fmt.Println(first)

	// Two slices built from the same prefix clobber each other.
	prefix := make([]string, 0, 4)
	prefix = append(prefix, "cmd")
	a := append(prefix, "build")
	b := append(prefix, "test")
	fmt.Println(a, b) // both print test
}

Ausgabe:

[1 2 100 4 5]
[1 2 100]
[cmd test] [cmd test]

a und b teilen sich den Platz im Array nach "cmd", also hat das zweite append das erste überschrieben. Der Code sieht gut aus und funktioniert, solange die Kapazität zufällig voll ist. Deshalb taucht dieser Bug nur manchmal auf.

Zwei Lösungen:

1. Der volle Slice-Ausdruck s[low:high:max] begrenzt die Kapazität auf max-low. Ohne freie Kapazität muss das nächste append neu anlegen. first := base[:2:2] macht das erste Beispiel sicher.
2. Explizit kopieren, wenn ein Slice den Aufruf überlebt oder unabhängig erweitert wird: slices.Clone(prefix) oder append([]string(nil), prefix...).

Eine verwandte Falle: Ein kleiner Slice eines riesigen Arrays hält für den Garbage Collector das ganze Array am Leben. Liest du eine Datei mit 100 MB und behältst data[:10], bleiben die 100 MB im Speicher. Kopier den Teil, den du behältst, mit Clone.

copy

Die eingebaute Funktion copy(dst, src) kopiert min(len(dst), len(src)) Elemente und gibt diese Anzahl zurück. Sie lässt dst nie wachsen.

package main

import (
	"fmt"
	"slices"
)

func main() {
	src := []int{1, 2, 3}

	dst := make([]int, len(src))
	n := copy(dst, src)
	dst[0] = 100
	fmt.Println(n, src, dst) // independent

	var empty []int
	fmt.Println(copy(empty, src)) // 0: dst has no length

	c := slices.Clone(src) // the one-line version (Go 1.21)
	fmt.Println(c)
}

copy behandelt überlappende Quelle und Ziel korrekt, also verschiebt copy(s[1:], s) Elemente nach rechts, ohne etwas zu beschädigen.

Das Paket slices

Seit Go 1.21 bietet das Standardpaket slices generische Helfer für die Operationen, die du früher von Hand geschrieben hast.

package main

import (
	"fmt"
	"slices"
)

func main() {
	s := []int{5, 2, 8, 2, 9}

	fmt.Println(slices.Contains(s, 8)) // true
	fmt.Println(slices.Index(s, 2))    // 1
	fmt.Println(slices.Max(s), slices.Min(s))

	slices.Sort(s)
	fmt.Println(s)
	i, found := slices.BinarySearch(s, 8)
	fmt.Println(i, found)

	s = slices.Compact(s) // drop adjacent duplicates
	fmt.Println(s)

	s = slices.Delete(s, 1, 2) // remove index 1
	fmt.Println(s)

	s = slices.Insert(s, 1, 3, 4)
	fmt.Println(s)

	slices.Reverse(s)
	fmt.Println(s, slices.Equal(s, []int{9, 8, 4, 3, 2}))
}

Delete und Insert geben einen Slice zurück, den du zuweisen musst, wie bei append. Sortieren hat eine eigene Seite: Sortieren.

Wer beim Durchlaufen per Index Elemente entfernt, überspringt Elemente. Nimm stattdessen slices.DeleteFunc:

s = slices.DeleteFunc(s, func(n int) bool { return n%2 == 0 }) // drop evens

2D-Slices

Ein Slice von Slices ergibt ein Raster, dessen Zeilen unterschiedlich lang sein können. Jede Zeile muss separat angelegt werden.

package main

import "fmt"

func main() {
	rows, cols := 3, 4
	grid := make([][]int, rows)
	for r := range grid {
		grid[r] = make([]int, cols)
	}
	grid[1][2] = 7

	for _, row := range grid {
		fmt.Println(row)
	}

	// Rows of different lengths are fine.
	triangle := [][]int{{1}, {1, 1}, {1, 2, 1}}
	fmt.Println(triangle)
}

Vergisst du das innere make, bleibt jede Zeile nil, und grid[1][2] = 7 löst eine Panic mit index out of range [2] with length 0 aus.

nil-Slices und leere Slices

package main

import (
	"encoding/json"
	"fmt"
)

func main() {
	var a []int  // nil
	b := []int{} // empty, not nil

	fmt.Println(len(a), len(b), a == nil, b == nil)

	a = append(a, 1) // append works on nil
	fmt.Println(a)

	ja, _ := json.Marshal(struct{ Items []int }{})
	jb, _ := json.Marshal(struct{ Items []int }{Items: []int{}})
	fmt.Println(string(ja), string(jb))
}

Ein nil-Slice verhält sich bei len, cap, range und append wie ein leerer, also nimm var s []T als Nullzustand. Initialisier mit []T{} nur, wenn der Unterschied zählt, und das ist vor allem bei JSON-Ausgaben der Fall (null vs []). Prüf Leere mit len(s) == 0, nicht mit s == nil.

Slices und Funktionen

Eine Funktion, die einen Slice bekommt, kann seine Elemente ändern, und der Aufrufer sieht die Änderungen. Die Länge beim Aufrufer kann sie nicht ändern, weil sie eine Kopie des Headers bekommen hat. Eine Funktion, die anhängt, muss den neuen Slice zurückgeben:

func addAll(s []int, vals ...int) []int {
	return append(s, vals...)
}

Deshalb geben append, slices.Delete und slices.Insert alle einen Slice zurück.

Häufige Fehler

• Das Ergebnis von append ignorieren. Wird es ganz verworfen, kompiliert der Code nicht, aber append(s, x) einer anderen Variablen zuzuweisen als der, die du weiter benutzt, ist ein Logikfehler.
• Zwei appends von derselben Basis. Sie können sich den Speicher teilen. Kopier die Basis mit Clone oder nimm einen vollen Slice-Ausdruck.
• make([]T, n) und dann append. Lässt n Nullen am Anfang stehen.
• Index außerhalb des Bereichs. s[len(s)] löst eine Panic aus. Das letzte Element ist s[len(s)-1].
• Slices mit == vergleichen. Nur s == nil kompiliert. Nimm slices.Equal.