dup vs clone, ou la copie qui ne descend pas dup vs clone, or the copy that doesn't go deep

dup copie l'objet — mais une seule couche.dup copies the object — but one layer only.

On a vu geler un niveau (freeze) ; voici copier un niveau (dup). dup crée bien un nouvel objet de premier niveau : on peut y ajouter, retirer, réordonner sans toucher l'original. Mais ses sous-objets ne sont pas copiés — ce sont les MÊMES, partagés avec l'original. Muter un sous-tableau de la copie mute celui de l'original, exactement l'aliasing du № 1, glissé un cran plus bas. La copie de surface règle le partage du contenant, jamais celui du contenu.We saw freezing one level (freeze); here's copying one level (dup). dup does create a new top-level object: you can add, remove, reorder without touching the original. But its sub-objects aren't copied — they're the SAME, shared with the original. Mutating a sub-array of the copy mutates the original's, exactly the № 1 aliasing, slipped one notch down. Shallow copy settles the container's sharing, never the contents'.

original = [[1, 2], [3, 4]]
copy = original.dup        # une copie… mais de SURFACE

copy << [5, 6]             # le 1er niveau est bien distinct
original                   # => [[1, 2], [3, 4]]   intact

copy[0] << 99              # mais copy[0] EST original[0]
original                   # => [[1, 2, 99], [3, 4]]  ← muté à distance
copy[0].equal?(original[0])  # => true   le même sous-objet, partagé

Le « snapshot » qui change quand l'original change.The "snapshot" that changes when the original changes.

Le cas le plus courant : on veut garder une photo d'un état avant de le modifier — un undo, une valeur de référence, un cache. On fait .dup, rassuré, puis on mute l'original… et la photo bouge avec lui. C'est que dup n'a copié que le contenant : chaque sous-objet est resté partagé entre l'original et la copie. Un tableau de tableaux, un Hash de Hash, un objet qui tient d'autres objets — partout où il y a un deuxième niveau, dup le laisse en commun. La copie ciblée, elle, duplique aussi la couche qu'on va toucher.The most common case: you want a photo of a state before changing it — an undo, a reference value, a cache. You .dup, reassured, then mutate the original… and the photo moves with it. That's because dup copied only the container: each sub-object stayed shared between original and copy. An array of arrays, a Hash of Hashes, an object holding other objects — wherever there's a second level, dup leaves it in common. The targeted copy, instead, duplicates the layer you're going to touch too.

# dup : un seul niveau copié, les sous-objets restent partagés
grid = [[0, 0], [0, 0]]
snapshot = grid.dup        # « je garde une copie de l'état avant calcul »

grid[0][1] = 9             # on modifie la grille de travail…

snapshot                   # => [[0, 9], [0, 0]]
                           #   ↑ le snapshot a changé AUSSI : sous-objets partagés
snapshot.equal?(grid)      # => false  contenants distincts
snapshot[0].equal?(grid[0])  # => true   MÊME ligne dessous

grid.dup crée un tableau extérieur neuf, mais snapshot[0] et grid[0] sont la même ligne. Écrire grid[0][1] = 9 mute cette ligne partagée — donc le snapshot aussi. La photo n'en était pas une : elle pointait sur le sujet vivant.grid.dup creates a fresh outer array, but snapshot[0] and grid[0] are the same row. Writing grid[0][1] = 9 mutates that shared row — so the snapshot too. The photo wasn't one: it pointed at the living subject.

dup et clone copient pareil — sauf deux choses.dup and clone copy the same — except for two things.

Les deux font une copie de surface, à l'identique pour le contenu. Leur différence tient en deux points, tous deux liés au Vol 4. Un : l'état gelé. clone préserve le frozen? de l'original (cloner un objet gelé donne un objet gelé) ; dup rend toujours une copie libre, mutable. Deux : la classe singleton — les méthodes définies sur cet objet précis. clone les emporte, dup les laisse. La règle pratique : clone pour une copie fidèle à l'identité de l'objet, dup pour repartir d'une copie nue et modifiable.Both make a shallow copy, identical for the contents. Their difference is two points, both tied to Vol 4. One: the frozen state. clone preserves the original's frozen? (cloning a frozen object yields a frozen one); dup always returns a free, mutable copy. Two: the singleton class — methods defined on that precise object. clone carries them, dup leaves them. The practical rule: clone for a copy faithful to the object's identity, dup to start from a bare, modifiable copy.

# Différence 1 — l'état gelé : clone le copie, dup l'oublie
s = "ruby".freeze
s.dup.frozen?     # => false  dup rend une copie LIBRE
s.clone.frozen?   # => true   clone préserve le gel
s.clone(freeze: false).frozen?  # => false  on peut le forcer

# Différence 2 — la classe singleton : clone la copie, dup non
obj = Object.new
def obj.special = 42        # une méthode définie sur CE seul objet

obj.clone.special          # => 42   clone emporte la classe singleton
obj.dup.special
# NoMethodError: undefined method 'special'   dup ne l'emporte pas

Dans 95 % des cas on veut dup : on copie un Array ou un Hash pour le modifier sans toucher l'original, et ni le gel ni le singleton n'entrent en jeu. clone sert quand l'objet est son identité — un objet configuré avec des méthodes propres, ou dont on veut préserver le caractère gelé. Mais aucun des deux ne résout le vrai sujet du numéro : la profondeur. Surface ou fidélité, ils s'arrêtent tous deux au premier niveau.In 95% of cases you want dup: you copy an Array or Hash to modify it without touching the original, and neither freeze nor singleton come into play. clone serves when the object is its identity — an object configured with its own methods, or whose frozen state you want preserved. But neither solves the issue's real subject: depth. Shallow or faithful, both stop at the first level.

La copie profonde « au cas où » : un bulldozer pour un seul niveau.The "just in case" deep copy: a bulldozer for one single level.

Le contre-exemple emblématique du numéro. Échaudé par le snapshot qui bougeait, on dégaine le réflexe Marshal.load(Marshal.dump(x)) « pour être vraiment sûr » — une copie profonde universelle. Mais c'est un bulldozer : il sérialise l'objet entier, y compris les vingt niveaux qu'on ne touchera jamais, coûte un ordre de grandeur de plus qu'une copie ciblée, et lève dès qu'un Proc, une IO ou une classe singleton se trouve dans le graphe. Quand on sait quel niveau on va muter — et on le sait presque toujours — une copie d'un cran à cet endroit précis suffit, et coûte mille fois moins.The issue's emblematic counter-example. Burned by the snapshot that moved, you reach for the Marshal.load(Marshal.dump(x)) reflex 'to be really sure' — a universal deep copy. But it's a bulldozer: it serializes the whole object, including the twenty levels you'll never touch, costs an order of magnitude more than a targeted copy, and raises the moment a Proc, an IO or a singleton class sits in the graph. When you know which level you'll mutate — and you almost always do — a one-notch copy at that precise spot is enough, and costs a thousand times less.

# Le réflexe « pour être sûr » : sérialiser TOUT l'objet, aller-retour
def snapshot(state)
  Marshal.load(Marshal.dump(state))   # copie profonde universelle
end

# … mais on ne mutait qu'UNE clé :
config = { name: "api", retries: 3, tags: ["prod"] }
copy = snapshot(config)
copy[:tags] << "beta"

# le coût caché de Marshal :
#  · sérialise l'objet ENTIER, même les niveaux qu'on ne touche pas
#  · lève sur un Proc, une IO, une lambda, une classe singleton
#  · plus lent d'un ordre de grandeur qu'une copie ciblée

# Copie ciblée : on duplique exactement le niveau qu'on va muter
config = { name: "api", retries: 3, tags: ["prod"] }
copy = config.merge(tags: config[:tags].dup)   # 1 niveau + le seul sous-objet visé

copy[:tags] << "beta"
config[:tags]   # => ["prod"]   ← intact, sans sérialiser quoi que ce soit

# si la forme est vraiment arbitraire et profonde, Marshal se justifie —
# mais comme choix mesuré, pas comme réflexe « au cas où »