Un Range rappresenta un intervallo di valori — (1..10) per numeri, ('a'..'z') per lettere, ecc. I range sono oggetti con metodi utili, usati per iterazione, slicing, test di appartenenza e matching case. Sono una caratteristica Ruby concisa ed espressiva.
(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 distinzione chiave: .. include la fine, ... la esclude (il terzo punto "spinge la fine via"). Un punto importante da ricordare.
(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]
I range includono Enumerable, quindi supportano each, map, select, ecc. — e to_a li materializza in un 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? testano l'appartenenza in modo efficiente (soprattutto cover?, che controlla solo gli endpoint senza iterare).
# 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)
I range sono una caratteristica utile ed espressiva di Ruby usata in molti scenari comuni, quindi comprenderli è una conoscenza preziosa nel lavoro quotidiano.
Rappresentano in modo conciso intervalli (numerici, alfabetici) e compaiono in diversi contesti frequenti: iterazione ((1..5).each — un modo pulito per ciclare su una sequenza), slicing di array e stringhe (arr[1..3], str[0..4] — estraendo sotto-sequenze elegantemente), test di appartenenza (include?/cover? — verificare se un valore cade in un intervallo, con cover? efficiente controllando solo gli endpoint), e soprattutto matching case/when (branching pulito basato su range, come valutazione per intervalli di punteggio — un pattern comune e leggibile).
Comprendere la importante distinzione .. (inclusivo) vs ... (esclusivo) è necessario per usare i range correttamente (ed è un punto di confusione comune).
Conoscere che i range includono Enumerable (quindi supportano map/select/ecc.), come usarli per iterazione, slicing, appartenenza e case matching, e le caratteristiche moderne (range infiniti/senza inizio) copre gli usi pratici.
Poiché i range compaiono frequentemente in Ruby idiomatico (iterazione, slicing, condizionali basati su range, validazione di intervalli di valori), e poiché sono un modo conciso ed espressivo per gestire intervalli, comprendere i range — la loro sintassi (inclusiva vs esclusiva), i metodi e gli usi comuni (iterazione, slicing, appartenenza, case matching) — è una conoscenza utile e praticamente rilevante per scrivere Ruby pulito e idiomatico che gestisce sequenze e intervalli elegantemente.