Blocks & yield, ou le contrôle qu'on délègue Blocks & yield, or the control you delegate

Le { … } n'est pas la boucle. C'est du code que tu confies.The { … } isn't the loop. It's code you hand over.

On lit each { |n| … } comme « la façon de boucler en Ruby ». C'est passer à côté de tout. each est une méthode ordinaire ; le bloc entre accolades est un morceau de code qu'on lui confie ; et c'est each qui décide de le rappeler — une fois par élément, via yield. La boucle n'est pas une construction du langage : c'est un objet à qui on a délégué le contrôle.We read each { |n| … } as 'how you loop in Ruby'. That misses everything. each is an ordinary method; the block in braces is a piece of code you hand it; and it's each that decides to call it back — once per element, via yield. The loop isn't a language construct: it's an object you've delegated control to.

[1, 2, 3].each { |n| puts n }
# le { |n| puts n } n'est pas "la boucle" :
# c'est un BLOC — un morceau de code — qu'on CONFIE à each.
# each le rappelle une fois par élément, avec yield.

def twice
  yield        # exécute le bloc qu'on m'a passé
  yield        # … et je décide de le rappeler une seconde fois
end

twice { puts "go" }   # affiche "go" deux fois

Ailleurs, tu boucles sur la collection. Ici, elle te rappelle.Elsewhere, you loop over the collection. Here, it calls you back.

Dans un langage statique, for et while sont des mots-clés : la boucle est dans le langage, et la collection se fait lire passivement de l'extérieur — c'est toi qui tiens l'index. Ruby renverse le sens. La collection sait itérer sur elle-même ; tu lui confies un bloc, et elle te rappelle. L'index, la condition, l'ordre : ce sont ses affaires, plus les tiennes.In a static language, for and while are keywords: the loop lives in the language, and the collection is read passively from the outside — you hold the index. Ruby reverses the direction. The collection knows how to iterate over itself; you hand it a block, and it calls you back. The index, the condition, the order: its business, no longer yours.

// Java : for est une CONSTRUCTION du langage
for (int i = 0; i < list.size(); i++) {
  System.out.println(list.get(i));
}
// c'est TOI qui tiens l'index, la condition, l'incrément.
// la collection est passive — elle se fait lire de l'extérieur.

Tu gères tout : l'index i, la condition d'arrêt, l'incrément, l'accès get(i). Une erreur sur l'un des quatre, et c'est un dépassement de borne ou une boucle infinie. La collection, elle, ne fait que se laisser lire.You manage everything: the index i, the stop condition, the increment, the get(i) access. A mistake on any of the four, and it's an out-of-bounds or an infinite loop. The collection merely lets itself be read.

yield rappelle ton bloc. ensure encadre ce qu'il y a autour.yield calls your block back. ensure brackets what's around it.

yield est le mot qui exécute le bloc reçu, autant de fois que la méthode le décide. block_given? lui demande s'il y a un bloc du tout. Avec ces deux-là, tu écris ton propre each — et tu découvres le vrai gain de l'inversion : la méthode peut faire quelque chose avant et après ton bloc. Ouvrir un fichier, le yield, puis le refermer quoi qu'il arrive. Ton bloc n'a plus à s'en soucier.yield is the word that runs the received block, as many times as the method decides. block_given? asks whether there's a block at all. With those two you write your own each — and you discover the real payoff of the inversion: the method can do something before and after your block. Open a file, yield it, then close it no matter what. Your block no longer has to care.

class Playlist
  def initialize(*songs) = @songs = songs

  def each
    return enum_for(:each) unless block_given?  # sans bloc → un Enumerator
    i = 0
    while i < @songs.size
      yield @songs[i]      # je rappelle ton bloc avec chaque chanson
      i += 1
    end
  end
end

Playlist.new("a", "b").each { |s| puts s }   # a, puis b

class Playlist   # on rouvre la classe ci-dessus, each compris
  include Enumerable      # le seul contrat exigé : un each qui yield
end

# … et tu obtiens map, select, sort, to_a, first… GRATUITEMENT.
Playlist.new("c", "a", "b").sort   # => ["a", "b", "c"]
# (on y revient au Vol 8 — ici, retiens : tout part de yield)

def with_logfile(path)
  f = File.open(path, "a")
  yield f                 # tu fais ce que tu veux du fichier…
ensure
  f&.close                # … et JE garantis la fermeture, même si ça lève
end

with_logfile("app.log") { |log| log.puts "démarré" }
# le fichier est refermé quoi qu'il arrive — c'est ça, encadrer un bloc

Voilà ce qu'une boucle ne saura jamais faire : la méthode exécute du code avant ton bloc (ouvrir), te le yield, puis exécute du code après (refermer) — et grâce à ensure, le « après » a lieu même si ton bloc lève une exception. Tu ne peux pas oublier de refermer : ce n'est plus ton travail.Here's what a loop can never do: the method runs code before your block (open), yields it to you, then runs code after (close) — and thanks to ensure, the "after" happens even if your block raises. You cannot forget to close: it's no longer your job.

Gérer la ressource « à la main », c'est reprendre le contrôle qu'on t'offrait.Managing the resource "by hand" is taking back the control you were offered.

Venant d'un langage où l'on ouvre et ferme soi-même, le réflexe est d'écrire f = File.open … f.close. Ça marche — tant que rien ne lève entre les deux. Le jour où une exception traverse, le close est sauté et le descripteur fuit. La forme à bloc existe précisément pour ça : elle encadre ton code d'un ensure que tu ne peux pas oublier. Ignorer le bloc, c'est refuser la garantie qu'il t'apportait.Coming from a language where you open and close yourself, the reflex is to write f = File.open … f.close. It works — as long as nothing raises in between. The day an exception passes through, the close is skipped and the descriptor leaks. The block form exists precisely for this: it brackets your code with an ensure you cannot forget. Ignoring the block is refusing the guarantee it gave you.

# Le réflexe « je gère moi-même » : ouvrir, faire, refermer
f = File.open("report.csv", "w")
f.puts header
write_rows(f, data)        # ← si CECI lève une exception…
f.close                    # … cette ligne n'est JAMAIS atteinte.

# Résultat : le descripteur de fichier fuit. Sous charge, à la longue,
# "Too many open files" — un bug qui n'apparaît qu'en production.

# Le correctif : confie le bloc, laisse la méthode encadrer
File.open("report.csv", "w") do |f|
  f.puts header
  write_rows(f, data)      # même si ça lève…
end                        # … File.open a un ensure interne : f est refermé.

# Tu ne peux PAS oublier de refermer : ce n'est plus ton travail.