Quelle est la différence entre les arrays et les slices ?

Question

Accepted Answer

Un **array** a une taille fixe qui fait partie de son type ; un **slice** est une vue flexible et de taille dynamique d'un array sous-jacent. En pratique, vous utilisez presque toujours des **slices** — les arrays sont rares dans le Go quotidien.

## Arrays — taille fixe

```go
var arr [5]int               // an array of exactly 5 ints (size is part of the type)
arr[0] = 10
fmt.Println(len(arr))        // 5 — size is fixed forever

// [3]int and [5]int are DIFFERENT types — can't assign one to the other
```

La taille d'un array est fixée à la compilation et fait partie de son type (`[5]int` ≠ `[3]int`). Les arrays sont aussi des **types valeur** — assigner ou passer un array copie tout l'array. Cette rigidité est la raison pour laquelle ils sont rarement utilisés directement.

## Slices — dynamiques et flexibles

```go
s := []int{1, 2, 3}          // a slice (no size in the brackets)
s = append(s, 4)             // grow it — append returns a new slice
fmt.Println(len(s), cap(s))  // length and capacity

nums := make([]int, 0, 10)   // make a slice: length 0, capacity 10 (pre-allocated)
```

Un slice n'a pas de taille fixe — vous le développez avec `append`. C'est la séquence dynamique de référence.

## Comment les slices fonctionnent sous le capot

```text
A slice is a small struct: { pointer to underlying array, length, capacity }
  - len = number of elements currently in the slice
  - cap = size of the underlying array from the slice's start
append: if len < cap, reuses the array; if len == cap, allocates a BIGGER array & copies
```

## Le slicing crée une vue (array de support partagé — une piège)

```go
original := []int{1, 2, 3, 4, 5}
sub := original[1:3]         // [2, 3] — a VIEW into the same backing array
sub[0] = 99                  // ⚠️ also changes original[1] → [1, 99, 3, 4, 5]!
```

Le slicing (`s[low:high]`) ne copie pas — il crée un nouvel en-tête de slice pointant sur le **même** array sous-jacent. Modifier l'un peut affecter l'autre — une source courante de bugs subtils. Utilisez `copy()` pour une copie indépendante.

## La surprise de réallocation d'append

```go
a := []int{1, 2, 3}
b := append(a, 4)            // may or may not share a's array depending on capacity
// safe pattern: always use the RETURNED slice from append
a = append(a, 4)
```

## Pourquoi c'est important

Les slices sont l'une des fonctionnalités les plus utilisées et les plus mal comprises de Go.

Comprendre que les arrays sont des types valeur de taille fixe (rarement utilisés directement) tandis que les **slices** sont des vues flexibles, quasi références, d'un array de support (l'outil quotidien) est fondamental.

De manière cruciale, connaître le **comportement d'array de support partagé** — que le slicing crée une vue, pas une copie, donc les modifications peuvent affecter d'autres slices, et que `append` peut ou ne pas réallouer — prévient une classe de bugs d'aliasing subtils et difficiles à déboguer qui surprennent même les développeurs expérimentés.

Maîtriser les slices (len vs cap, append, copy, les pièges de partage) est une connaissance Go quotidienne essentielle et un sujet d'entretien fréquent, car presque tout le travail de collection les utilise.