Tableaux en Golang : longueur fixe, copie par valeur, différence avec les slices

Déclarer un tableau

Un type tableau s'écrit [N]T : une longueur, puis un type d'élément. La longueur est fixée à la compilation et fait partie du type.

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)
}

Sortie :

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

Un tableau est toujours entièrement initialisé. Les éléments que vous ne définissez pas contiennent la valeur zéro du type : 0, "", false, nil.

Indices et bornes

Les indices vont de 0 à len(a)-1. Un indice constant hors limites est une erreur de compilation. Un indice variable hors limites provoque un panic à l'exécution.

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

Parcourir un tableau

for i, v := range a visite chaque élément dans l'ordre. v est une copie de l'élément, donc affecter une valeur à v ne modifie pas le tableau. Écrivez plutôt via l'indice.

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)
}

Il existe une subtilité propre aux tableaux : range sur une valeur tableau évalue une copie du tableau dès le départ. Si le corps de la boucle modifie des éléments plus loin, v affiche encore les anciennes valeurs. Parcourir &a ou a[:] évite la copie.

Les tableaux sont des valeurs

C'est la principale différence avec les tableaux de C, Java ou JavaScript. Affecter un tableau copie chaque élément. Le passer à une fonction le copie aussi.

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)
}

Sortie :

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

La copie est bon marché pour les petits tableaux et coûteuse pour les gros : passer un [1_000_000]int par valeur copie huit mégaoctets. Passez un pointeur (*[N]T) ou une slice (a[:]) quand le tableau est grand ou que la fonction doit le modifier. Indexer via un pointeur de tableau ne demande pas de * explicite : a[0] fonctionne sur un *[3]int.

Comparer des tableaux et s'en servir comme clés de map

Les tableaux d'éléments comparables acceptent == et !=. Deux tableaux sont égaux quand chaque élément est égal. Cela en fait aussi des clés de map valides, ce que les slices ne sont pas.

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}])
}

Des tableaux de longueurs différentes sont des types différents et ne peuvent pas être comparés du tout : [3]int{} == [4]int{} ne compile pas (mismatched types [3]int and [4]int).

Tableaux multidimensionnels

Un tableau de tableaux vous donne une grille fixe. La grille entière occupe un seul bloc de mémoire contigu.

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[:] transforme la ligne [3]rune en slice []rune, que string() accepte.

Tableau ou slice

En pratique, vous croiserez surtout des tableaux à quelques endroits : sha256.Sum256 renvoie un [32]byte, les tables de correspondance dont la taille ne change jamais, et le stockage sous-jacent d'une slice. Découper un tableau avec a[:] ou a[1:3] crée une slice qui partage sa mémoire ; la page sur les slices explique ce que ce partage implique.

Convertir entre tableaux et slices

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)
}

Convertir une slice en tableau (Go 1.20) ou en pointeur de tableau (Go 1.17) provoque un panic si la slice est plus courte que la longueur du tableau : panic: runtime error: cannot convert slice with length 2 to array or pointer to array with length 3.

Erreurs courantes

• S'attendre à ce qu'une fonction modifie un tableau passé en argument. Elle en reçoit une copie. Passez *[N]T ou une slice.
• Utiliser un tableau là où une slice est attendue. []int{1, 2} est une slice, [2]int{1, 2} est un tableau. Une fonction qui prend []int n'acceptera pas un [2]int ; passez a[:].
• De gros tableaux dans une boucle range. for _, v := range bigArray copie d'abord tout le tableau. Parcourez &bigArray ou une slice.