Un Range (interval) reprezintă un set de valori — (1..10) pentru numere, ('a'..'z') pentru litere, etc. Intervalele sunt obiecte cu metode utile, utilizate pentru iterație, extragere de sub-secvențe, teste de apartenență și potrivire case. Sunt o caracteristică concisă și expresivă a Ruby.
(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
Distincția cheie: .. include capătul, ... îl exclude (al treilea punct "îndepărtează capătul"). Un punct important de reținut.
(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]
Intervalele includ Enumerable, deci acceptă each, map, select, etc. — și to_a le materializează într-un tablou.
(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? testează apartenența eficient (în special cover?, care verifică doar capetele fără a itera).
# 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)
Intervalele sunt o caracteristică utilă și expresivă a Ruby utilizată în multe scenarii frecvente, deci înțelegerea lor este cunoaștere valoroasă pentru uzul zilnic.
Reprezintă concis intervale (numerice, alfabetice) și apar în mai contexte frecvente: iterație ((1..5).each — o modalitate curată de a parcurge o secvență), extragere din tablouri și șiruri (arr[1..3], str[0..4] — extragerea de sub-secvențe elegant), teste de apartenență (include?/cover? — verificarea dacă o valoare cade într-un interval, cu cover? fiind eficient prin verificarea doar a capetelor), și în special potrivire case/when (ramificație curată bazată pe intervale, cum ar fi notarea după intervale de punctaje — un model frecvent și ușor de citit).
Înțelegerea distinctiei importante .. (inclusiv) vs ... (exclusiv) este necesară pentru a folosi corect intervalele (și un punct frecvent de confuzie).
Cunoașterea faptului că intervalele includ Enumerable (deci acceptă map/select/etc.), cum să le utilizezi pentru iterație, extragere, apartenență și potrivire case, și caracteristicile moderne (intervale fără sfârșit/fără început) acoperă utilizările practice.
Din moment ce intervalele apar frecvent în Ruby idiomativ (iterație, extragere, condiționare bazată pe intervale, validarea intervalelor de valori), și din moment ce sunt o modalitate concisă și expresivă de a gestiona intervale, înțelegerea intervalelor — sintaxa lor (inclusiv vs exclusiv), metodele, și utilizările frecvente (iterație, extragere, apartenență, potrivire case) — este cunoaștere utilă și practic relevantă pentru scrierea unui Ruby curat și idiomativ care gestionează elegant secvențe și intervale.