Golang Array: feste Länge, Wertsemantik, Unterschied zu Slices

Ein Array deklarieren

Ein Array-Typ wird [N]T geschrieben: eine Länge, dann ein Elementtyp. Die Länge steht zur Compilezeit fest und ist Teil des Typs.

package main

import "fmt"

func main() {
	var scores [5]int // five zeros
	scores[0] = 90
	scores[4] = 75
	fmt.Println(scores, len(scores))

	days := [3]string{"Mon", "Tue", "Wed"}
	fmt.Println(days[1])

	primes := [...]int{2, 3, 5, 7, 11} // compiler counts: [5]int
	fmt.Printf("%T %v\n", primes, primes)

	// Index keys: unset positions get the zero value.
	sparse := [5]string{1: "b", 3: "d"}
	fmt.Printf("%q\n", sparse)
}

Ausgabe:

[90 0 0 0 75] 5
Tue
[5]int [2 3 5 7 11]
["" "b" "" "d" ""]

Ein Array ist immer vollständig initialisiert. Elemente, die du nicht setzt, haben den Nullwert des Elementtyps: 0, "", false, nil.

Indizes und Grenzen

Indizes laufen von 0 bis len(a)-1. Ein konstanter Index außerhalb des Bereichs ist ein Compilerfehler. Ein variabler Index außerhalb des Bereichs löst zur Laufzeit eine Panic aus.

var a [3]int
a[5] = 1 // compile error: invalid argument: index 5 out of bounds [0:3]

i := 5
a[i] = 1 // panic: runtime error: index out of range [5] with length 3

Durchlaufen

for i, v := range a besucht jedes Element der Reihe nach. v ist eine Kopie des Elements, eine Zuweisung an v ändert das Array also nicht. Schreib stattdessen über den Index.

package main

import "fmt"

func main() {
	temps := [4]float64{21.5, 23.0, 19.8, 25.1}

	sum := 0.0
	for _, t := range temps {
		sum += t
	}
	fmt.Printf("average: %.2f\n", sum/float64(len(temps)))

	for i := range temps {
		temps[i] += 1 // modifies the array
	}
	fmt.Println(temps)
}

Eine Feinheit gibt es speziell bei Arrays: range über einen Array-Wert wertet vorab eine Kopie des Arrays aus. Ändert der Rumpf spätere Elemente, zeigt v trotzdem die alten Werte. Mit range über &a oder a[:] vermeidest du die Kopie.

Arrays sind Werte

Das ist der Hauptunterschied zu Arrays in C, Java oder JavaScript. Eine Zuweisung kopiert jedes Element. Auch die Übergabe an eine Funktion kopiert das Array.

package main

import "fmt"

func reset(a [3]int) {
	a[0] = 0 // changes the function's copy
}

func resetPtr(a *[3]int) {
	a[0] = 0 // changes the caller's array
}

func main() {
	a := [3]int{1, 2, 3}
	b := a // full copy
	b[0] = 99
	fmt.Println(a, b)

	reset(a)
	fmt.Println(a)

	resetPtr(&a)
	fmt.Println(a)
}

Ausgabe:

[1 2 3] [99 2 3]
[1 2 3]
[0 2 3]

Bei kleinen Arrays ist das Kopieren billig, bei großen teuer: Ein [1_000_000]int als Wert zu übergeben kopiert acht Megabyte. Übergib einen Pointer (*[N]T) oder einen Slice (a[:]), wenn das Array groß ist oder die Funktion es ändern soll. Beim Indizieren über einen Array-Pointer brauchst du kein explizites *: a[0] funktioniert auf einem *[3]int.

Arrays vergleichen und als Map-Schlüssel nutzen

Arrays mit vergleichbaren Elementen unterstützen == und !=. Zwei Arrays sind gleich, wenn jedes Element gleich ist. Damit sind sie auch gültige Map-Schlüssel, Slices dagegen nicht.

package main

import "fmt"

func main() {
	x := [3]int{1, 2, 3}
	y := [3]int{1, 2, 3}
	fmt.Println(x == y)

	// A grid position as a map key.
	type pos [2]int
	visited := map[pos]bool{}
	visited[pos{0, 0}] = true
	visited[pos{2, 1}] = true
	fmt.Println(visited[pos{2, 1}], visited[pos{1, 1}])
}

Arrays unterschiedlicher Länge sind verschiedene Typen und lassen sich gar nicht vergleichen: [3]int{} == [4]int{} kompiliert nicht (mismatched types [3]int and [4]int).

Mehrdimensionale Arrays

Ein Array aus Arrays ergibt ein festes Raster. Das ganze Raster ist ein zusammenhängender Speicherblock.

package main

import "fmt"

func main() {
	var board [3][3]rune
	for r := range board {
		for c := range board[r] {
			board[r][c] = '.'
		}
	}
	board[1][1] = 'X'
	board[0][2] = 'O'

	for _, row := range board {
		fmt.Println(string(row[:]))
	}
}

row[:] macht aus der [3]rune-Zeile einen []rune-Slice, den string() akzeptiert.

Arrays vs Slices

In der Praxis begegnen dir Arrays vor allem an wenigen Stellen: sha256.Sum256 gibt ein [32]byte zurück, Lookup-Tabellen, deren Größe sich nie ändert, und als Speicher hinter einem Slice. Slicen eines Arrays mit a[:] oder a[1:3] erzeugt einen Slice, der sich den Speicher mit dem Array teilt; was dieses Teilen bedeutet, erklärt die Seite zu Slices.

Zwischen Arrays und Slices konvertieren

package main

import "fmt"

func main() {
	arr := [4]int{1, 2, 3, 4}
	s := arr[:] // slice view: shares memory with arr
	s[0] = 100
	fmt.Println(arr)

	nums := []int{7, 8, 9}
	a := [3]int(nums) // Go 1.20: slice to array, copies
	nums[0] = 0
	fmt.Println(a, nums)

	p := (*[3]int)(nums) // Go 1.17: array pointer, shares memory
	p[1] = 0
	fmt.Println(nums)
}

Die Konvertierung eines Slices in ein Array (Go 1.20) oder einen Array-Pointer (Go 1.17) löst eine Panic aus, wenn der Slice kürzer ist als die Array-Länge: panic: runtime error: cannot convert slice with length 2 to array or pointer to array with length 3.

Häufige Fehler

• Erwarten, dass eine Funktion ein Array-Argument ändert. Sie bekommt eine Kopie. Übergib *[N]T oder einen Slice.
• Ein Array verwenden, wo ein Slice erwartet wird. []int{1, 2} ist ein Slice, [2]int{1, 2} ein Array. Eine Funktion, die []int nimmt, akzeptiert kein [2]int; übergib a[:].
• Große Arrays in einer range-Schleife. for _, v := range bigArray kopiert zuerst das ganze Array. Nimm range über &bigArray oder einen Slice.