Ruby offre les structures de contrôle standard (, , ) mais avec des fonctionnalités distinctives et expressives : les (), , le puissant , et une préférence pour l' plutôt que les boucles traditionnelles. Le contrôle de flux en Ruby se lit naturellement.
ifcasewhiledo_x if conditionunlesscase/whenif age >= 18
puts "adult"
elsif age >= 13
puts "teen"
else
puts "child"
end
# MODIFIER form — condition at the END (reads like English, idiomatic for short cases)
puts "adult" if age >= 18
puts "minor" unless age >= 18 # `unless` = if not (more readable than `if !`)
# everything is an expression — if returns a value
grade = if score >= 90 then "A" else "B" end
La forme modificatrice de Ruby (puts "x" if condition) place la condition à la fin pour des one-liners concis et lisibles. unless (= « si non ») se lit plus naturellement qu'une négation. Et if est une expression qui retourne une valeur.
case status
when :active then "running"
when :stopped, :paused then "halted" # multiple values
when 1..10 then "small number" # ranges
when String then "it's a string" # types (uses ===)
else "unknown"
end
# case can also do structural pattern matching (Ruby 3)
case data
in { name: String => name, age: Integer } # pattern matching with destructuring
puts name
end
Le case/when de Ruby est puissant — il correspond à des valeurs, des plages, des types, et (en Ruby 3) des motifs structurels, en utilisant === en coulisse. Beaucoup plus flexible qu'un simple switch.
while count < 10 do count += 1 end
until done do ... end # until = while not
# ✅ but Ruby PREFERS iteration with blocks over explicit loops:
5.times { |i| puts i } # instead of a for loop
[1, 2, 3].each { |n| puts n } # iterate a collection
(1..10).each { |n| ... } # iterate a range
1.upto(5) { |i| ... }
Ruby a while/until, mais le Ruby idiomatique préfère l'itération avec des blocs (each, times, map) aux boucles explicites — plus expressif et plus « Ruby ».
Comprendre le contrôle de flux de Ruby est une connaissance fondamentale au quotidien, et plusieurs fonctionnalités distinctives reflètent la philosophie expressive et lisible de Ruby.
La forme modificatrice (do_x if condition) et unless (= « si non ») vous permettent d'écrire des conditionnelles concises et ressemblant à l'anglais qui sont idiomatiques en Ruby et apparaissent constamment.
Le fait que if soit une expression (retournant une valeur) permet des assignations élégantes.
Le case/when de Ruby est remarquablement puissant — correspondant à des valeurs, des plages, des types, et (en Ruby 3) des motifs structurels via === — ce qui le rend bien plus flexible qu'un switch basique et utile pour des ramifications multi-voies propres.
Crucalement, le Ruby idiomatique préfère l'itération avec des blocs (each, times, map, upto) aux boucles for/while traditionnelles — c'est un point de style déterminant : les développeurs Ruby itèrent les collections et plages avec des méthodes basées sur des blocs plutôt qu'avec des boucles explicites, ce qui est plus expressif et plus « Ruby ».
Comprendre ces constructions et idiomes — la forme modificatrice et unless pour des conditionnelles lisibles, le puissant case/when, et surtout la préférence pour l'itération basée sur des blocs plutôt que les boucles explicites — est important pour écrire et lire du Ruby idiomatique.
Comme le contrôle de flux apparaît dans chaque programme, et puisque les formes expressives de Ruby (modificatrices, unless, case puissant, itération par bloc) incarnent sa philosophie axée sur la lisibilité, les maîtriser est une connaissance essentielle et fondamentale pour écrire du Ruby naturel et idiomatique plutôt que de traduire des motifs lourd en boucles d'autres langages.