Une slice n'est pas un tableau. C'est une vue sur un tableau — trois mots, pas des données.A slice isn't an array. It's a view over an array — three words, not data.
Quatre volumes durant, on a déplacé des valeurs sans jamais regarder ce qu'elles sont, physiquement, en mémoire. Le volume 5 ouvre cette boîte, et commence par l'objet le plus quotidien de Go — celui qu'on utilise chaque heure et qu'on se représente presque toujours faux. La slice n'est pas un tableau qui grandit. C'est une structure minuscule de trois champs : un pointeur vers un tableau sous-jacent, une longueur, et une capacité. Le tableau, lui, vit ailleurs. Cette distinction n'est pas un détail d'implémentation à oublier : elle gouverne tout le comportement de la slice. Affecter une slice à une autre variable, la passer à une fonction, la trancher — aucune de ces opérations ne copie les données. Elles copient les trois mots, et te laissent deux vues sur le même tableau. Comprendre cela, c'est comprendre d'avance toutes les surprises du volume.For four volumes, we moved values without ever looking at what they physically are in memory. Volume 5 opens that box, and starts with Go's most everyday object — the one you use hourly and almost always picture wrong. A slice isn't an array that grows. It's a tiny structure of three fields: a pointer to an underlying array, a length, and a capacity. The array itself lives elsewhere. This distinction isn't an implementation detail to forget: it governs the slice's entire behavior. Assigning a slice to another variable, passing it to a function, slicing it — none of these operations copy the data. They copy the three words, and leave you two views over the same array. To understand this is to understand, in advance, every surprise in the volume.
// un tableau : une VALEUR de taille fixe. L'affecter copie tout. a := [3]int{10, 20, 30} b := a // b est une copie complète des trois éléments b[0] = 99 fmt.Println(a, b) // [10 20 30] [99 20 30] — b est indépendant
// une slice : une VUE de trois mots, posée sur un tableau sous-jacent. a := []int{10, 20, 30} // pas de taille dans le type : c'est une vue b := a // b copie les trois mots (ptr, len, cap), pas les données b[0] = 99 // b.ptr et a.ptr visent le MÊME tableau fmt.Println(a, b) // [99 20 30] [99 20 30] — a a changé aussi
Quand tu copies une slice, tu copies la boîte de gauche — trois mots — jamais celle de droite. Deux slices peuvent avoir des en-têtes différents (len, cap, point de départ) tout en visant le même tableau. La donnée est partagée par défaut ; c'est le cœur de tout ce qui suit.When you copy a slice, you copy the left box — three words — never the right one. Two slices can have different headers (len, cap, starting point) while pointing at the same array. The data is shared by default; that's the heart of everything that follows.
« Une slice est une vue ; la copier copie la vue, pas les données. » Tout le confort de la slice — trancher en O(1), passer sans coût, partager un tampon — vient de là. Tous ses pièges aussi. Le même fait — c'est une vue, pas un conteneur — explique l'élégance et le danger. Le volume ne fait que décliner cette phrase : sur le partage (ce numéro), sur la croissance (le n°2), sur le cas particulier de la map (le n°3)."A slice is a view; copying it copies the view, not the data." All the slice's comfort — O(1) slicing, free passing, sharing a buffer — comes from this. So do all its traps. The same fact — it's a view, not a container — explains the elegance and the danger. The volume just conjugates that sentence: over sharing (this issue), over growth (issue 2), over the map's special case (issue 3).
Go a des tableaux de taille fixe — [3]int — mais on les croise rarement directement, parce qu'ils sont rigides : la taille fait partie du type, [3]int et [4]int sont incompatibles, et les affecter copie tout. La slice est la couche pratique posée par-dessus : une fenêtre redimensionnable sur un tableau qu'on ne nomme presque jamais. Quand tu écris une slice littérale, Go alloue silencieusement le tableau sous-jacent et te rend une vue dessus. Le tableau n'a pas disparu ; il est devenu invisible. Et c'est précisément parce qu'on ne le voit plus qu'on oublie qu'il est partagé — l'oubli d'où naissent toutes les surprises qui suivent.Go has fixed-size arrays — [3]int — but you rarely meet them directly, because they're rigid: the size is part of the type, [3]int and [4]int are incompatible, and assigning them copies everything. The slice is the practical layer laid on top: a resizable window over an array you almost never name. When you write a slice literal, Go silently allocates the underlying array and hands you a view over it. The array hasn't vanished; it's become invisible. And it's precisely because you no longer see it that you forget it's shared — the forgetting from which every following surprise is born.