En Range repræsenterer et interval af værdier — (1..10) for tal, ('a'..'z') for bogstaver osv. Ranges er objekter med nyttige metoder, brugt til iteration, slicing, medlemskabstest og case matching. De er en kortfattet, udtryksfuld 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
Hovedforskellen: .. inkluderer enden, ... udelukker den (det tredje punkt "skubber enden væk"). Et vigtigt punkt at huske.
(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 inkluderer Enumerable, så de understøtter each, map, select osv. — og to_a materialiserer dem til et 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? tester medlemskab effektivt (især cover?, som blot kontrollerer endepunkterne uden at iterere).
# 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 er en nyttig, udtryksfuld Ruby-funktion brugt i mange almindelige scenarier, så at forstå dem er værdifuldt daglig viden.
De repræsenterer koncist intervaller (numeriske, alfabetiske) og vises i flere hyppige sammenhænge: iteration ((1..5).each — en ren måde at loope over en sekvens), slicing af arrays og strings (arr[1..3], str[0..4] — ekstraktion af delsekvenser elegant), medlemskabstest (include?/cover? — kontrol af, om en værdi falder i et interval, hvor cover? er effektiv ved blot at kontrollere endepunkter), og især case/when matching (ren range-baseret forgrening, som karaktergivning efter scoreintervaller — et almindeligt, læseligt mønster).
Forståelse af den vigtige .. (inklusiv) vs ... (eksklusiv) sondring er nødvendig for at bruge ranges korrekt (og er et almindeligt forvirringspoint).
At vide, at ranges inkluderer Enumerable (så de understøtter map/select/osv.), hvordan man bruger dem til iteration, slicing, medlemskab og case matching, og moderne funktioner (endless/beginless ranges) dækker de praktiske anvendelser.
Da ranges vises hyppigt i idiomatisk Ruby (iteration, slicing, range-baseret betingelser, validering af værdiintervaller), og da de er en kortfattet, udtryksfuld måde at håndtere intervaller på, er det at forstå ranges — deres syntaks (inklusiv vs eksklusiv), metoder og almindelige anvendelser (iteration, slicing, medlemskab, case matching) — brugbar, praktisk relevant viden for at skrive rent, idiomatisk Ruby, som håndterer sekvenser og intervaller elegant.