En Range representerar ett intervall av värden — (1..10) för tal, ('a'..'z') för bokstäver, etc. Ranges är objekt med användbara metoder, används för iteration, slicing, medlemskapstest, och case-matchning. De är en koncis, uttrycksfull 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
Huvudskillnaden: .. inkluderar slutet, ... exkluderar det (den tredje punkten "skjuter slutet bort"). En viktig punkt att komma ihåg.
(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 inkluderar Enumerable, så de stöder each, map, select, etc. — och to_a materialiserar dem till en 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? testar medlemskap effektivt (särskilt cover?, som bara kontrollerar ändpunkterna utan iteration).
# 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 är en användbar, uttrycksfull Ruby-funktion som används i många vanliga scenarier, så att förstå dem är värdefull daglig kunskap.
De representerar koncist intervall (numeriska, alfabetiska) och förekommer i flera frekventa sammanhang: iteration ((1..5).each — ett rent sätt att loopa över en sekvens), slicing arrays och strängar (arr[1..3], str[0..4] — extrahera del-sekvenser elegant), medlemskapstest (include?/cover? — kontrollera om ett värde faller inom ett intervall, där cover? är effektiv genom att bara kontrollera ändpunkterna), och särskilt case/when-matchning (ren intervallbaserad förgrening, som betygsättning efter poängintervall — ett vanligt, läsligt mönster).
Att förstå den viktiga .. (inklusiv) vs ... (exklusiv) distinktionen är nödvändig för att använda ranges korrekt (och en vanlig förvirrningspunkt).
Att veta att ranges inkluderar Enumerable (så de stöder map/select/etc.), hur man använder dem för iteration, slicing, medlemskap, och case-matchning, och moderna funktioner (endless/beginless ranges) täcker de praktiska användningarna.
Eftersom ranges förekommer ofta i idiomatisk Ruby (iteration, slicing, intervallbaserade villkor, validering av värdintervall), och eftersom de är ett koncist, uttrycksfull sätt att hantera intervall, är att förstå ranges — deras syntax (inklusiv vs exklusiv), metoder, och vanliga användningar (iteration, slicing, medlemskap, case-matchning) — användbar, praktiskt relevant kunskap för att skriva ren, idiomatisk Ruby som hanterar sekvenser och intervall elegant.
Ett bibliotek med IT-intervjufrågor och detaljerade svar — från Junior till Senior.
Donera