Ein Range stellt ein Intervall von Werten dar — (1..10) für Zahlen, ('a'..'z') für Buchstaben, etc. Ranges sind Objekte mit nützlichen Methoden, die zur Iteration, zum Slicing, zu Zugehörigkeitstests und zum case-Matching verwendet werden. Sie sind eine prägnante, ausdrucksstarke Ruby-Funktion.
(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
Die wichtigste Unterscheidung: .. schließt das Ende ein, ... schließt es aus (der dritte Punkt "schiebt das Ende weg"). Ein wichtiger Punkt zum Merken.
(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]
Ranges enthalten Enumerable, daher unterstützen sie each, map, select, etc. — und to_a materialisiert sie in ein Array.
(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? testen Zugehörigkeit effizient (besonders cover?, das nur die Endpunkte prüft, ohne zu iterieren).
# 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)
Ranges sind eine nützliche, ausdrucksstarke Ruby-Funktion, die in vielen häufigen Szenarien verwendet wird, daher ist das Verständnis dafür wertvoll im alltäglichen Umgang.
Sie stellen prägnant Intervalle dar (numerisch, alphabetisch) und erscheinen in mehreren häufigen Kontexten: Iteration ((1..5).each — eine saubere Möglichkeit, über eine Sequenz zu iterieren), Slicing von Arrays und Strings (arr[1..3], str[0..4] — elegantes Extrahieren von Teilsequenzen), Zugehörigkeitstests (include?/cover? — Überprüfung, ob ein Wert in ein Intervall fällt, wobei cover? effizient ist, da es nur die Endpunkte prüft), und besonders case/when-Matching (saubere range-basierte Verzweigung, wie Bewertung nach Score-Bereichen — ein häufiges, lesbares Muster).
Das Verständnis der wichtigen Unterscheidung .. (inklusive) vs ... (exklusiv) ist notwendig, um Ranges korrekt zu verwenden (und ein häufiger Verwirrungspunkt).
Das Wissen, dass Ranges Enumerable enthalten (daher map/select/etc. unterstützen), wie man sie zur Iteration, zum Slicing, zu Zugehörigkeitstests und zum Case-Matching verwendet, und moderne Features (endlose/anfanglose Ranges) decken die praktischen Anwendungen ab.
Da Ranges häufig in idiomatischem Ruby vorkommen (Iteration, Slicing, range-basierte Bedingungen, Validierung von Wertebereichen), und da sie eine prägnante, ausdrucksstarke Möglichkeit sind, Intervalle zu handhaben, ist das Verständnis von Ranges — ihre Syntax (inklusive vs exklusiv), Methoden und häufige Anwendungen (Iteration, Slicing, Zugehörigkeit, Case-Matching) — nützliches, praktisch relevantes Wissen zum Schreiben von sauberem, idiomatischem Ruby, das Sequenzen und Intervalle elegant handhabt.