Tout est copié Everything is copied

En Go, passer une valeur, c'est la copier — struct comprise, champ par champ. Parfois c'est un service (une copie ne peut pas être mutée ailleurs), parfois c'est un coût (une grosse struct recopiée à chaque appel). Savoir lequel, c'est tout l'art. In Go, passing a value copies it — structs included, field by field. Sometimes that's a gift (a copy can't be mutated elsewhere), sometimes a cost (a big struct re-copied on every call). Knowing which is the whole craft.

Audience
Dev qui modifie une struct dans une fonction et s'étonne que l'original n'ait pas bougé Dev who modifies a struct in a function and is surprised the original didn't move
ChapitresChapters
5
LectureReading
≈ 16 min
NiveauLevel
●●○○
Date
Sep 2027 Sep 2027

ValeurCopie

SommaireContents ·
№ 01CadrageFraming3 min

En Go, dès que tu passes une valeur, tu la copies. C'est la règle qui gouverne tout le reste.In Go, the moment you pass a value, you copy it. That's the rule governing everything else.

Le volume 5 nous a montré des structures qui partagent une mémoire sous-jacente — une slice et son tableau, une map et sa table. On pourrait en conclure que partager est la norme en Go. C'est l'exact contraire. Le comportement par défaut du langage, celui dont tout le reste découle, c'est la copie. Assigner une variable à une autre, passer un argument à une fonction, ranger une valeur dans un tableau ou la renvoyer d'une fonction : à chacun de ces gestes, Go duplique la valeur, champ par champ. Pas de référence implicite, pas de partage caché — une copie franche, dont les modifications n'ont aucun effet sur l'original. C'est vrai des entiers, c'est vrai des structs, c'est vrai des tableaux de taille fixe. Cette sémantique de valeur a deux visages, et tout l'art consiste à savoir lequel tu regardes. Côté pile, c'est un service : une copie ne peut pas être mutée à distance, donc une fonction qui reçoit ta struct ne peut pas, par mégarde, corrompre la tienne. Côté face, c'est un coût : une grosse struct recopiée à chaque appel, c'est de la mémoire et du temps dépensés à dupliquer. Comprendre la sémantique de valeur, c'est savoir reconnaître, à chaque passage, lequel des deux tu paies — et choisir un pointeur quand le coût l'emporte, ou quand tu veux justement muter l'original.Volume 5 showed us structures that share an underlying memory — a slice and its array, a map and its table. You might conclude that sharing is the norm in Go. It's the exact opposite. The language's default behavior, the one everything else flows from, is the copy. Assigning one variable to another, passing an argument to a function, storing a value in an array or returning it from a function: at each of these moves, Go duplicates the value, field by field. No implicit reference, no hidden sharing — a clean copy, whose modifications have no effect on the original. It's true of integers, true of structs, true of fixed-size arrays. This value semantics has two faces, and the whole craft is knowing which one you're looking at. Heads, it's a gift: a copy can't be mutated at a distance, so a function receiving your struct can't accidentally corrupt yours. Tails, it's a cost: a big struct re-copied on every call is memory and time spent duplicating. Understanding value semantics is knowing how to recognize, at each pass, which of the two you're paying — and choosing a pointer when the cost wins, or when you actually want to mutate the original.

Assignation : la copie est indépendanteAssignment: the copy is independent
type Point struct{ X, Y int }

a := Point{1, 2}
b := a                  // COPIE : b est un Point indépendant, champ par champ
b.X = 99
fmt.Println(a)          // {1 2}   ← a intact, aucun lien avec b
fmt.Println(b)          // {99 2}
Appel de fonction : l'argument est copié, l'original protégéFunction call: the argument is copied, the original protected
func reset(p Point) {   // p est une COPIE de l'argument passé
    p.X = 0             // … on modifie la copie locale, pas l'original
}

a := Point{1, 2}
reset(a)                // a est copié dans p au moment de l'appel
fmt.Println(a)          // {1 2}   ← reset n'a jamais touché le vrai a
La copie a deux visagesThe copy has two faces
un service
une copie ne peut pas être mutée ailleurs — ta valeur est protégée
|
un coût
une grosse struct recopiée à chaque passage — mémoire et temps

La même opération — copier — est tantôt une protection, tantôt une dépense. Rien dans le code ne dit lequel ; c'est la taille de la valeur et ton intention qui tranchent. Tout le volume apprend à lire ce choix.The same operation — copying — is sometimes a protection, sometimes an expense. Nothing in the code says which; it's the value's size and your intent that decide. The whole volume teaches you to read that choice.

Le réflexe du numéroThe issue's reflex

« Je passe une valeur ? alors je passe une copie — sauf si je passe un pointeur. » C'est la grille de lecture de tout le langage. Une fonction ne peut muter ce que tu lui donnes que si tu lui donnes l'adresse, pas la valeur. Le volume 5 était l'exception qui partage ; celui-ci est la règle qui isole. Et il révèle au passage pourquoi la slice et la map se comportaient si différemment : ce qu'on en copie, c'est leur en-tête, pas leur contenu."Am I passing a value? then I'm passing a copy — unless I pass a pointer." It's the reading grid for the entire language. A function can only mutate what you give it if you give it the address, not the value. Volume 5 was the exception that shares; this one is the rule that isolates. And it reveals along the way why the slice and the map behaved so differently: what you copy of them is their header, not their content.

« Copié », ce n'est pas « cloné en profondeur »'Copied' isn't 'deep-cloned'

Un point de vocabulaire, qu'on déplie au chapitre 3 : copier une valeur en Go, c'est dupliquer ses champs tels quels — pas suivre récursivement ce vers quoi ils pointent. Copier une struct qui contient un int et un bool donne deux champs neufs, totalement indépendants. Mais copier une struct qui contient une slice duplique l'en-tête de la slice — ses trois mots — sans dupliquer le tableau sous-jacent. Les deux copies pointent alors vers le même tableau. C'est une copie « de surface » (shallow), et c'est le pont exact entre ce volume et le précédent : la sémantique de valeur copie fidèlement, mais ce qu'elle copie d'une slice, c'est précisément la vue partagée qu'on a étudiée tout le volume 5.A point of vocabulary, unfolded in chapter 3: copying a value in Go duplicates its fields as they are — not recursively following what they point to. Copying a struct holding an int and a bool gives two fresh, fully independent fields. But copying a struct holding a slice duplicates the slice's header — its three words — without duplicating the underlying array. Both copies then point at the same array. It's a 'shallow' copy, and it's the exact bridge between this volume and the last: value semantics copies faithfully, but what it copies of a slice is precisely the shared view we studied all through volume 5.

№ 02La surpriseThe surprise4 min

Tu modifies un champ dans une fonction, tu reviens, et rien n'a changé. La fonction n'a vu qu'une copie.You modify a field inside a function, you return, and nothing changed. The function only ever saw a copy.

Voici la surprise qui cueille tout débutant en Go, et qui découle directement de la règle du chapitre 1. Tu écris une fonction qui prend une struct, lui modifie un champ, et tu t'attends à ce que l'appelant voie le changement. Il ne le voit pas. La fonction a reçu une copie de ta struct ; elle a consciencieusement modifié cette copie ; et la copie a disparu au retour, emportant tes modifications avec elle. Du point de vue de l'appelant, rien ne s'est passé. Ce n'est pas un bug du langage, c'est la sémantique de valeur appliquée à la lettre — mais elle déroute parce qu'elle est silencieuse : aucune erreur, aucun avertissement, juste un effet qui ne se produit pas. La parade tient en un caractère : passer l'adresse de la struct plutôt que la struct elle-même. Avec un pointeur, la fonction ne reçoit plus une copie des données, mais l'emplacement où elles vivent ; modifier *a, c'est modifier l'original, et le changement persiste. C'est le même basculement que la slice nous a appris à l'envers : là, on souffrait d'un partage qu'on ne voulait pas ; ici, on souffre d'une isolation qu'on ne voulait pas. Dans les deux cas, la question est la même — partagé ou copié ? — et c'est à toi d'y répondre, explicitement.Here's the surprise that catches every Go beginner, and it follows directly from chapter 1's rule. You write a function taking a struct, you modify one of its fields, and you expect the caller to see the change. It doesn't. The function received a copy of your struct; it dutifully modified that copy; and the copy vanished on return, taking your modifications with it. From the caller's point of view, nothing happened. It's not a language bug, it's value semantics applied to the letter — but it disorients because it's silent: no error, no warning, just an effect that doesn't occur. The fix fits in one character: pass the struct's address rather than the struct itself. With a pointer, the function no longer receives a copy of the data, but the location where it lives; modifying *a is modifying the original, and the change persists. It's the same switch the slice taught us in reverse: there, we suffered a sharing we didn't want; here, we suffer an isolation we didn't want. In both cases, the question is the same — shared or copied? — and it's on you to answer it, explicitly.

Passée par valeur : la fonction mute une copie mortePassed by value: the function mutates a dead copy
type Account struct{ Balance int }

func deposit(a Account, amount int) {   // a : COPIE de l'argument
    a.Balance += amount                 // … on crédite la copie locale
}

a := Account{Balance: 100}
deposit(a, 50)
fmt.Println(a.Balance)   // 100  ← le dépôt s'est perdu avec la copie

Le code est parfaitement logique et fait exactement ce qu'il dit — il crédite a.Balance. Simplement, le a qu'il crédite n'est pas celui de l'appelant : c'est la copie née au moment de l'appel. L'effet attendu n'arrive jamais, et aucun signal ne te prévient. C'est la version « isolation subie » du piège : tu voulais muter l'original, la sémantique de valeur t'a donné une copie. Le compilateur ne peut pas deviner ton intention — pour lui, modifier une copie locale est une opération parfaitement valide.The code is perfectly logical and does exactly what it says — it credits a.Balance. It's just that the a it credits isn't the caller's: it's the copy born at the moment of the call. The expected effect never arrives, and no signal warns you. It's the "isolation suffered" version of the trap: you wanted to mutate the original, value semantics handed you a copy. The compiler can't guess your intent — to it, modifying a local copy is a perfectly valid operation.

La même question que la slice, retournéeThe same question as the slice, flipped

Au volume 5, le danger était de partager sans le vouloir : un append sur une sous-slice corrompait l'original. Ici, le danger est l'inverse exact — copier sans le vouloir : une fonction modifie une struct et l'original ne bouge pas. Ce sont les deux faces d'une seule question, celle qui structure tout Go : cette valeur est-elle partagée ou copiée ? La slice répondait « partagée » par défaut et il fallait forcer la copie ; la struct répond « copiée » par défaut et il faut forcer le partage avec un pointeur. Savoir, pour chaque type, quelle est la réponse par défaut — voilà la compétence que ce volume installe.In volume 5, the danger was sharing unintentionally: an append on a sub-slice corrupted the original. Here, the danger is the exact opposite — copying unintentionally: a function modifies a struct and the original doesn't move. They're the two faces of a single question, the one structuring all of Go: is this value shared or copied? The slice answered "shared" by default and you had to force the copy; the struct answers "copied" by default and you must force sharing with a pointer. Knowing, for each type, what the default answer is — that's the skill this volume installs.

« Je l'ai modifié et rien n'a changé » a presque toujours une seule cause. Tu as muté une copie. Passe un pointeur."I modified it and nothing changed" almost always has a single cause. You mutated a copy. Pass a pointer.
№ 03La mécaniqueThe mechanics5 min

« Copié champ par champ » est littéral. Pour un champ slice, ce qu'on copie, c'est l'en-tête — pas le tableau."Copied field by field" is literal. For a slice field, what you copy is the header — not the array.

La sémantique de valeur copie une struct champ par champ, et il faut prendre cette phrase au pied de la lettre pour comprendre où elle s'arrête. Chaque champ est dupliqué tel qu'il est, sans suivre ce vers quoi il pointe. Si le champ est un int, un bool, une string, un autre struct par valeur, la copie est totale et indépendante : modifier la copie ne touche jamais l'original. Mais si le champ est une slice, une map, un pointeur, ou un canal, alors « copier le champ » signifie copier l'en-tête — les quelques mots qui décrivent où sont les données — pas les données elles-mêmes. Et un en-tête de slice, on l'a vu tout le volume 5, c'est un pointeur vers un tableau partagé. Résultat : la copie de la struct et l'originale possèdent chacune leur propre en-tête de slice, mais ces deux en-têtes désignent le même tableau sous-jacent. Modifier un élément via l'une se voit dans l'autre. C'est ce qu'on appelle une copie de surface, ou shallow copy, et c'est le comportement par défaut, sans exception. Go ne fait jamais de copie profonde implicite : ce serait coûteux, et souvent indésirable. Si tu veux une copie réellement indépendante d'une struct qui contient des slices ou des maps, c'est à toi de cloner ces champs, un par un. C'est ici, exactement, que le modèle de données du volume 5 se branche sur la sémantique de valeur du volume 6 : la struct se copie fidèlement, mais ce qu'elle copie d'une slice, c'est la vue partagée, pas son contenu.Value semantics copies a struct field by field, and you must take that sentence literally to understand where it stops. Each field is duplicated as it is, without following what it points to. If the field is an int, a bool, a string, another struct by value, the copy is total and independent: modifying the copy never touches the original. But if the field is a slice, a map, a pointer, or a channel, then 'copying the field' means copying the header — the few words describing where the data is — not the data itself. And a slice header, as we saw all through volume 5, is a pointer to a shared array. Result: the struct's copy and the original each own their own slice header, but those two headers designate the same underlying array. Modifying an element through one shows in the other. This is called a shallow copy, and it's the default behavior, no exception. Go never makes an implicit deep copy: it would be costly, and often undesirable. If you want a truly independent copy of a struct holding slices or maps, it's on you to clone those fields, one by one. This is exactly where volume 5's data model plugs into volume 6's value semantics: the struct copies faithfully, but what it copies of a slice is the shared view, not its content.

Champs valeur : la copie est totalement détachéeValue fields: the copy is fully detached
type Config struct {
    Name    string
    Timeout int
}

a := Config{"prod", 30}
b := a                 // copie : chaque champ est dupliqué tel quel
b.Name = "dev"
b.Timeout = 60
fmt.Println(a)         // {prod 30}  ← a totalement indépendant de b

Tant que tous les champs sont des valeurs — nombres, booléens, strings, structs imbriqués par valeur — la copie est ce qu'on en attend : un double parfaitement indépendant. C'est le cas le plus fréquent, et le plus sûr : passer une telle struct à une fonction garantit qu'elle ne sera pas modifiée à distance. La string mérite une note : même si elle référence des octets, elle est immuable en Go, donc la partager ne crée aucun risque de mutation. Pour le raisonnement, traite la string comme une valeur.As long as all fields are values — numbers, booleans, strings, structs nested by value — the copy is what you'd expect: a perfectly independent double. It's the most frequent case, and the safest: passing such a struct to a function guarantees it won't be modified at a distance. The string deserves a note: even though it references bytes, it's immutable in Go, so sharing it creates no mutation risk. For reasoning, treat the string as a value.

Copie profonde : à toi de cloner les champs référenceDeep copy: it's on you to clone the reference fields
// pour une copie réellement indépendante, clone les champs référence
b := a                          // copie de surface (en-têtes partagés)
b.Tags = slices.Clone(a.Tags)   // … puis on détache la slice explicitement

b.Tags[0] = "ZZZ"
fmt.Println(a.Tags)    // [x y]  ← a intact : les tableaux sont désormais distincts

Il n'existe pas de deepcopy intégré en Go, et c'est volontaire : le langage refuse de deviner jusqu'où copier. Pour détacher réellement deux structs, tu copies la struct (copie de surface) puis tu remplaces chaque champ référence par un clone — slices.Clone pour une slice, maps.Clone pour une map, une copie manuelle pour un pointeur. La sémantique de valeur t'offre l'isolation pour les champs plats, et te laisse la décision pour les champs partagés. C'est cohérent avec tout le langage : ce qui coûte ou ce qui partage reste explicite, jamais magique.There's no built-in deepcopy in Go, and that's deliberate: the language refuses to guess how far to copy. To truly detach two structs, you copy the struct (shallow copy) then replace each reference field with a clone — slices.Clone for a slice, maps.Clone for a map, a manual copy for a pointer. Value semantics gives you isolation for flat fields, and leaves you the decision for shared ones. It's consistent with the whole language: what costs or what shares stays explicit, never magic.

Copier une struct copie ses en-têtes, pas ce qu'ils désignent. Pour isoler un champ slice ou map, clone-le toi-même.Copying a struct copies its headers, not what they designate. To isolate a slice or map field, clone it yourself.
№ 04Le piègeThe trap4 min

La copie protège, mais elle se paie. Une boucle range sur de grosses structs recopie chaque élément — pour rien.The copy protects, but it has a price. A range loop over big structs recopies every element — for nothing.

L'autre face de la sémantique de valeur, c'est son coût, et il se cache dans des endroits qu'on ne soupçonne pas. Le plus courant est la boucle range. Quand tu écris for _, v := range gros, à chaque tour, v reçoit une copie complète de l'élément. Sur une slice de mille structs d'un kilo-octet, c'est un méga-octet recopié à chaque parcours — et si, en plus, tu modifies v en croyant modifier l'élément, non seulement tu paies la copie, mais ta modification se perd, exactement comme au chapitre 2. La parade est d'itérer sur les indices et d'adresser l'élément en place, rows[i], ou d'en prendre l'adresse, &rows[i], ce qui évite la copie et permet de muter. Au-delà de range, la même logique s'applique à tout passage de grosse struct par valeur : un argument, un retour, un champ. Cela ne veut pas dire « toujours prendre un pointeur » — pour les petites structs, la copie est souvent plus rapide qu'une indirection, et toujours plus sûre. Mais cela impose une grille de décision claire. Il n'y a que deux vraies raisons de préférer un pointeur à une valeur : tu veux muter l'original, ou la valeur est assez grosse pour que sa copie pèse. En l'absence de ces deux raisons, la valeur reste le défaut — plus simple, plus sûr, et souvent plus performant qu'on ne le croit.The other face of value semantics is its cost, and it hides in places you wouldn't suspect. The most common is the range loop. When you write for _, v := range big, on each iteration, v receives a full copy of the element. On a slice of a thousand one-kilobyte structs, that's a megabyte recopied per pass — and if, on top of that, you modify v thinking you modify the element, not only do you pay the copy, your modification is lost, exactly as in chapter 2. The fix is to iterate over the indices and address the element in place, rows[i], or take its address, &rows[i], which avoids the copy and allows mutation. Beyond range, the same logic applies to any big-struct pass by value: an argument, a return, a field. This doesn't mean 'always take a pointer' — for small structs, the copy is often faster than an indirection, and always safer. But it imposes a clear decision grid. There are only two real reasons to prefer a pointer to a value: you want to mutate the original, or the value is big enough that its copy weighs. Absent those two reasons, the value stays the default — simpler, safer, and often more performant than you'd think.

range par valeur : une copie complète à chaque tourrange by value: a full copy each iteration
type Row struct {
    data [1024]byte    // ~1 Ko par élément
    id   int
}

rows := make([]Row, 1000)
for _, r := range rows {    // r est une COPIE de chaque Row : ~1 Ko × 1000
    r.id = -1               // … on modifie la copie, jetée à chaque tour
}
fmt.Println(rows[0].id)     // 0  ← rien n'a changé, et 1 Mo recopié pour rien

Deux bugs en un. Le visible : la modification de r.id se perd, car r est une copie — le piège du chapitre 2 dans une boucle. L'invisible : même si tu ne modifiais rien, ce range recopie un méga-octet à chaque parcours, un coût pur qui n'apparaît nulle part dans le texte. Sur de petites structs il est négligeable ; sur de grosses, c'est l'une des causes les plus discrètes de lenteur en Go. Le profileur le révèle, le code ne le crie pas.Two bugs in one. The visible one: the modification of r.id is lost, since r is a copy — chapter 2's trap in a loop. The invisible one: even if you modified nothing, this range recopies a megabyte per pass, a pure cost appearing nowhere in the text. On small structs it's negligible; on big ones, it's one of the most discreet causes of slowness in Go. The profiler reveals it, the code doesn't shout it.

Deux raisons, deux seules, de prendre un pointeurTwo reasons, only two, to take a pointer

La décision se résume à deux questions. Veux-tu muter l'original ? Si oui, pointeur — c'est la seule façon. La valeur est-elle grosse au point que la copier coûte ? Si oui, pointeur, pour l'éviter. Si la réponse aux deux est non — petite struct qu'on ne modifie pas — alors la valeur gagne : pas d'indirection, pas de question d'aliasing, et le compilateur l'optimise bien. Ne prends pas un pointeur « par habitude » ; prends-le pour l'une de ces deux raisons, nommément.The decision boils down to two questions. Do you want to mutate the original? If yes, pointer — it's the only way. Is the value big enough that copying it costs? If yes, pointer, to avoid it. If both answers are no — a small struct you don't modify — then value wins: no indirection, no aliasing question, and the compiler optimizes it well. Don't take a pointer "by habit"; take it for one of those two reasons, by name.

La même décision, bientôt collée à un typeThe same decision, soon attached to a type

Jusqu'ici, valeur ou pointeur était une décision qu'on prenait au cas par cas, à chaque fonction. Le prochain numéro la fige au niveau du type lui-même. Quand tu écris une méthode, tu choisis une fois pour toutes son receveur : func (t T) travaille sur une copie, func (t *T) sur l'original. Ce choix ne change pas seulement si la méthode peut muter — il décide aussi quelles méthodes existent sur une valeur et lesquelles sur un pointeur, donc ce qui peut satisfaire une interface. La sémantique de valeur, qu'on vient d'apprendre à lire fonction par fonction, devient une propriété attachée au type. Vol. 6 №02 — Le receveur, valeur ou pointeur.So far, value or pointer was a decision taken case by case, at each function. The next issue freezes it at the level of the type itself. When you write a method, you choose its receiver once and for all: func (t T) works on a copy, func (t *T) on the original. That choice doesn't only change whether the method can mutate — it also decides which methods exist on a value and which on a pointer, hence what can satisfy an interface. Value semantics, which we've just learned to read function by function, becomes a property attached to the type. Vol. 6 №02 — The receiver, value or pointer.

Le défaut, c'est la valeur. Le pointeur se mérite par une raison nommée : muter l'original, ou éviter une grosse copie.The default is the value. The pointer is earned by a named reason: mutate the original, or avoid a big copy.
№ 05Bilan & éditoWrap-up & editorial2 min

Une seule question gouverne tout Go : cette valeur est-elle copiée ou partagée ? Par défaut, copiée.A single question governs all of Go: is this value copied or shared? By default, copied.

Ce numéro a posé la règle première du langage : passer une valeur, c'est la copier — champ par champ, sans suivre les pointeurs. La copie a deux visages : un service, parce qu'une copie ne peut pas être mutée à distance et protège donc l'original ; un coût, parce qu'une grosse struct recopiée à chaque passage dépense mémoire et temps. La surprise du débutant — « je l'ai modifié et rien n'a changé » — n'est que cette règle vue de près : la fonction a muté une copie, et il fallait passer un pointeur pour atteindre l'original. La mécanique précise le « champ par champ » : une copie est de surface, donc un champ slice ou map reste partagé, et c'est le pont exact avec le volume 5. Le piège, lui, est le coût caché : une boucle range recopie chaque grosse struct, qu'on le veuille ou non. D'où la grille de décision, valable partout : valeur par défaut, pointeur seulement pour muter l'original ou éviter une copie qui pèse. Cette grille, on va maintenant la figer dans le type lui-même, à travers le receveur des méthodes.This issue laid down the language's first rule: passing a value copies it — field by field, without following pointers. The copy has two faces: a gift, because a copy can't be mutated at a distance and thus protects the original; a cost, because a big struct recopied at each pass spends memory and time. The beginner's surprise — 'I modified it and nothing changed' — is just that rule seen up close: the function mutated a copy, and you had to pass a pointer to reach the original. The mechanics refine the 'field by field': a copy is shallow, so a slice or map field stays shared, and that's the exact bridge with volume 5. The trap is the hidden cost: a range loop recopies each big struct, want it or not. Hence the decision grid, valid everywhere: value by default, pointer only to mutate the original or avoid a copy that weighs. This grid, we'll now freeze into the type itself, through methods' receivers.

L'idéeThe ideaLa règleThe ruleSi tu la ratesIf you miss it
Tout est copiéEverything is copiedAssigner, passer, retourner : Go duplique la valeur, champ par champ.Assign, pass, return: Go duplicates the value, field by field.Tu modifies dans une fonction, l'original ne bouge pas.You modify inside a function, the original doesn't move.
Muter = pointeurMutate = pointerPour qu'un changement remonte, passe l'adresse : &v, et *T en paramètre.For a change to climb back, pass the address: &v, and *T as parameter.Tes modifications meurent avec la copie, en silence.Your modifications die with the copy, silently.
Copie de surfaceShallow copyUn champ slice / map copie l'en-tête : le tableau reste partagé.A slice / map field copies the header: the array stays shared.Tu mutes la « copie » et l'original change avec elle.You mutate the 'copy' and the original changes with it.
Le coût cachéThe hidden costrange par valeur recopie chaque élément ; pour les grosses structs, indexe.range by value recopies each element; for big structs, index.Une lenteur invisible au code, que seul le profileur révèle.A slowness invisible to the code, revealed only by the profiler.
Le volume 5 t'apprenait à te méfier de ce qui se partage en secret. Celui-ci t'apprend que tout le reste, par défaut, se copie — et que muter exige de le demander.Volume 5 taught you to distrust what shares in secret. This one teaches that everything else, by default, copies — and that mutating requires asking for it.
Mot de l'éditeurFrom the editor

Que Go copie par défaut n'est pas un détail d'implémentation. C'est une position morale sur qui a le droit de changer tes données.That Go copies by default isn't an implementation detail. It's a moral stance on who has the right to change your data.

On présente souvent la sémantique de valeur comme un choix de performance, ou un héritage du C. C'est sous-estimer ce qu'elle dit. Quand tu passes une struct par valeur, tu offres à la fonction une copie qu'elle peut triturer sans jamais toucher la tienne : l'isolation est la garantie par défaut, pas l'exception. Dans un langage où tout est référence, la question « cette fonction va-t-elle modifier mon objet ? » n'a pas de réponse locale — il faut lire le code de la fonction, et celui de ce qu'elle appelle. En Go, la réponse est dans la signature : si elle prend T, ton original est intouchable ; si elle prend *T, elle demande le droit de le changer, et ce droit est visible à l'appel, dans le & que tu écris toi-même. Le partage n'est jamais subi ; il est accordé. C'est la même philosophie que partout dans la série : rendre explicite ce que d'autres langages laissent implicite, quitte à te faire écrire un caractère de plus.Value semantics is often presented as a performance choice, or a C inheritance. That underestimates what it says. When you pass a struct by value, you hand the function a copy it can knead without ever touching yours: isolation is the default guarantee, not the exception. In a language where everything is a reference, the question 'will this function modify my object?' has no local answer — you must read the function's code, and that of what it calls. In Go, the answer is in the signature: if it takes T, your original is untouchable; if it takes *T, it's asking for the right to change it, and that right is visible at the call site, in the & you write yourself. Sharing is never suffered; it's granted. It's the same philosophy as everywhere in the series: make explicit what other languages leave implicit, even if it makes you write one more character.

Le prochain numéro prend cette même décision — valeur ou pointeur — et l'attache au type. Une méthode déclare son receveur une fois : func (t T) reçoit une copie et ne peut rien muter ; func (t *T) reçoit l'adresse et travaille sur l'original. Mais le choix va plus loin qu'il n'en a l'air. Il ne décide pas seulement si la méthode mute : il décide quelles méthodes appartiennent à la valeur et lesquelles au pointeur — ce qu'on appelle le jeu de méthodes. Et de là découle une question qui nous ramène droit au volume 3 : qu'est-ce qui satisfait une interface ? Une méthode à receveur pointeur n'entre pas dans le jeu de méthodes de la valeur, si bien qu'un type peut implémenter une interface par son pointeur mais pas par sa valeur. C'est l'une des erreurs les plus fréquentes du langage, et elle naît exactement ici, dans le choix du receveur. Vol. 6 №02 — Le receveur, valeur ou pointeur.The next issue takes this same decision — value or pointer — and attaches it to the type. A method declares its receiver once: func (t T) receives a copy and can mutate nothing; func (t *T) receives the address and works on the original. But the choice goes further than it looks. It doesn't only decide whether the method mutates: it decides which methods belong to the value and which to the pointer — what's called the method set. And from that flows a question taking us straight back to volume 3: what satisfies an interface? A pointer-receiver method doesn't enter the value's method set, so a type can implement an interface through its pointer but not through its value. It's one of the language's most frequent errors, and it's born exactly here, in the choice of receiver. Vol. 6 №02 — The receiver, value or pointer.