Qu'est-ce que les blocs en Ruby ?

Question

Accepted Answer

Un **bloc** est un morceau de code passé à une méthode, entre `{ }` (une ligne) ou `do...end` (multi-lignes). Les blocs sont une caractéristique distinctive et centrale de Ruby — c'est ainsi que vous passez un comportement à des méthodes, ce qui alimente l'itération, les callbacks, et le style élégant et expressif de Ruby.

## Syntaxe des blocs

```ruby
# { } for single-line blocks
[1, 2, 3].each { |n| puts n }

# do...end for multi-line blocks
[1, 2, 3].each do |n|
  doubled = n * 2
  puts doubled
end
```

Un bloc est passé à une méthode (ici `each`), qui appelle le bloc pour chaque élément. Les `|n|` déclarent le paramètre du bloc (la valeur passée en argument). Les deux syntaxes sont équivalentes ; la convention utilise `{ }` pour les blocs courts et `do...end` pour les plus longs.

## Les blocs alimentent l'itération et la transformation

```ruby
[1, 2, 3, 4].map { |n| n * 2 }              # [2, 4, 6, 8] — transform each
[1, 2, 3, 4].select { |n| n.even? }          # [2, 4] — filter
[1, 2, 3, 4].reduce(0) { |sum, n| sum + n }  # 10 — accumulate
3.times { |i| puts i }                        # 0, 1, 2
[1, 2, 3].each_with_index { |val, i| ... }
```

Les blocs sont comment Ruby fait l'itération et la transformation de données — vous passez le « quoi faire » sous forme de bloc, et la méthode gère l'itération. C'est plus élégant que les boucles explicites.

## Les blocs pour la gestion des ressources

```ruby
# blocks elegantly handle setup/teardown — the file is auto-closed after the block
File.open("data.txt") do |file|
  puts file.read
end   # file automatically closed here, even if an error occurs
```

Les méthodes peuvent utiliser des blocs pour des motifs setup/cleanup (comme s'assurer qu'un fichier est fermé) — la méthode gère la ressource, appelant votre bloc entre les deux.

## Le raccourci &:method

```ruby
[1, 2, 3].map { |n| n.to_s }    # full block
[1, 2, 3].map(&:to_s)            # shorthand — &:method calls that method on each element
["a", "b"].map(&:upcase)         # ["A", "B"]
```

Le raccourci `&:method` est un idiome concis pour les blocs qui font juste appeler une méthode sur chaque élément.

## Pourquoi c'est important

Les blocs sont l'une des caractéristiques les plus distinctives et centrales de Ruby — ils sont fondamentaux à la façon dont Ruby fonctionne et à son style élégant et expressif, donc les comprendre est essentiel pour tout développement en Ruby.

Les blocs sont comment vous **passez un comportement à des méthodes**, ce qui alimente l'approche signature de Ruby en **itération et transformation de données** : au lieu d'écrire des boucles explicites, vous passez un bloc décrivant quoi faire avec chaque élément (`map`, `select`, `reduce`, `each`), et la méthode gère l'itération — résultant en code concis, lisible, de style fonctionnel qui est quintessentiellement Ruby.

Les blocs permettent aussi des motifs élégants de **gestion des ressources** (une méthode gère setup/teardown, comme fermer automatiquement un fichier, appelant votre bloc entre les deux).

Comprendre la syntaxe des blocs (`{ }` vs `do...end`), comment les blocs reçoivent des paramètres (`|n|`), comment ils alimentent les méthodes Enumerable qui apparaissent constamment en Ruby, et les idiomes comme le **raccourci `&:method`** est une connaissance fondamentale, incontournable — les blocs apparaissent dans pratiquement chaque ligne de Ruby idiomatique (chaque itération, transformation, et beaucoup d'appels de méthode).

Ce que les blocs sont centraux à la conception et au style expressif de Ruby — permettant son itération élégante, ses callbacks, et ses motifs de gestion des ressources — maîtriser les blocs est absolument essentiel pour lire et écrire du Ruby, et ils sont une caractéristique déterminante qui distingue l'approche de Ruby des langages s'appuyant sur des boucles explicites, les rendant un sujet fréquent et important pour comprendre le langage.