Een Range vertegenwoordigt een interval van waarden — (1..10) voor getallen, ('a'..'z') voor letters, enzovoort. Ranges zijn objecten met nuttige methoden, gebruikt voor iteratie, slicing, lidmaatschapstests en case matching. Ze zijn een beknopt en expressief Ruby-feature.
(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
Het belangrijkste onderscheid: .. includes het einde, ... excludes het (de derde punt "duwt het einde weg"). Een belangrijk punt om onthouden.
(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 include Enumerable, dus ze ondersteunen each, map, select, enzovoort. — en to_a zet ze om in een 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 lidmaatschap efficiënt (vooral cover?, die alleen eindpunten controleert zonder te itereren).
# 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 zijn een nuttig, expressief Ruby-feature dat in veel veelvoorkomende scenario's wordt gebruikt, dus het begrijpen ervan is waardevol dagelijkse kennis.
Ze vertegenwoordigen beknopt intervallen (numeriek, alfabetisch) en verschijnen in verschillende frequente contexten: iteratie ((1..5).each — een schone manier om over een reeks te lopen), slicing van arrays en strings (arr[1..3], str[0..4] — het elegant extraheren van sub-sequences), lidmaatschapstesting (include?/cover? — controleren of een waarde in een interval valt, waarbij cover? efficiënt is door alleen eindpunten te controleren), en vooral case/when matching (schoon range-gebaseerd branching, zoals beoordelen op basis van score-intervallen — een veelvoorkomend, leesbaar patroon).
Het begrijpen van het belangrijke .. (inclusive) vs ... (exclusive) onderscheid is noodzakelijk om ranges correct te gebruiken (en een veelvoorkomend verwarringsmoment).
Weten dat ranges Enumerable include (dus ondersteunen map/select/enzovoort.), hoe je ze voor iteratie, slicing, lidmaatschap en case matching gebruikt, en moderne features (endless/beginless ranges) dekt de praktische toepassingen.
Omdat ranges veel voorkomen in idiomatische Ruby (iteratie, slicing, range-gebaseerde conditionals, validatie van waardebereiken), en omdat ze een beknopt, expressief manier zijn om met intervallen om te gaan, is het begrijpen van ranges — hun syntaxis (inclusive vs exclusive), methoden en veelvoorkomende toepassingen (iteratie, slicing, lidmaatschap, case matching) — nuttige, praktisch relevante kennis voor het schrijven van schoon, idiomatisch Ruby dat reeksen en intervallen elegant behandelt.