Une Range représente un intervalle de valeurs — (1..10) pour les nombres, ('a'..'z') pour les lettres, etc. Les ranges sont des objets avec des méthodes utiles, utilisés pour l'itération, le slicing, les tests d'appartenance et le matching case. C'est une fonctionnalité Ruby concise et expressive.
Pourquoi c'est important
(1..5) # INCLUSIVE — 1, 2, 3, 4, 5 (includes the end)
(1...5) # EXCLUSIVE — 1, 2, 3, 4 (excludes the end)
('a'..'e') # 'a', 'b', 'c', 'd', 'e' — works on letters too
La distinction clé : .. inclut la fin, ... l'exclut (le troisième point « repousse la fin »). Un point important à retenir.
Itération et conversion
(1..5).each { |n| puts n } # iterate — 1 to 5
(1..5).to_a # [1, 2, 3, 4, 5] — convert to an array
(1..10).map { |n| n * 2 } # ranges support Enumerable methods
(1..100).sum # 5050
(1..10).select(&:even?) # [2, 4, 6, 8, 10]
Les ranges incluent Enumerable, donc ils supportent each, map, select, etc. — et to_a les matérialise en tableau.
Test d'appartenance (efficace)
(1..100).include?(50) # true
(1..100).cover?(50) # true — faster (doesn't iterate, just checks endpoints)
age = 25
(18..65).include?(age) # check if a value falls in a range
include?/cover? testent l'appartenance efficacement (notamment cover?, qui vérifie simplement les extrémités sans itérer).
Ranges dans les case statements et le slicing
# case/when with ranges — clean range-based branching
grade = case score
when 90..100 then "A"
when 80..89 then "B"
when 0..79 then "F"
end
# array/string slicing with ranges
[10, 20, 30, 40, 50][1..3] # [20, 30, 40] — slice by range
"hello world"[0..4] # "hello" — substring by range
# endless/beginless ranges (Ruby 2.6+)
arr[2..] # from index 2 to the end
(1..) # 1 to infinity (with lazy evaluation)
Pourquoi c'est important
Les ranges sont une fonctionnalité Ruby utile et expressive utilisée dans de nombreux scénarios courants, donc les comprendre est une connaissance précieuse au quotidien.
Els représentent de façon concise des intervalles (numériques, alphabétiques) et apparaissent dans plusieurs contextes fréquents : l'itération ((1..5).each — un moyen élégant de boucler sur une séquence), le slicing de tableaux et de chaînes (arr[1..3], str[0..4] — extraire des sous-séquences élégamment), les tests d'appartenance (include?/cover? — vérifier si une valeur se situe dans un intervalle, cover? étant efficace en ne vérifiant que les extrémités), et surtout le matching case/when (un branchement basé sur les ranges net, comme la notation par plages de scores — un motif courant et lisible).
Comprendre la distinction importante .. (inclusif) vs ... (exclusif) est nécessaire pour utiliser les ranges correctement (et c'est un point de confusion courant).
Connaître les ranges qui incluent Enumerable (ils supportent donc map/select/etc.), comment les utiliser pour l'itération, le slicing, l'appartenance et le matching de cas, et les fonctionnalités modernes (ranges infinis/sans début) couvre les utilisations pratiques.
Puisque les ranges apparaissent fréquemment en Ruby idiomatique (itération, slicing, conditions basées sur les ranges, validation de plages de valeurs), et puisqu'ils constituent un moyen concis et expressif de gérer les intervalles, comprendre les ranges — leur syntaxe (inclusive vs exclusive), leurs méthodes et leurs usages courants (itération, slicing, appartenance, matching de cas) — est une connaissance utile et pratiquement pertinente pour écrire du Ruby propre et idiomatique qui traite les séquences et les intervalles élégamment.