Um Range representa um intervalo de valores — (1..10) para números, ('a'..'z') para letras, etc. Ranges são objetos com métodos úteis, usados para iteração, slicing, testes de pertencimento e correspondência em case. Eles são um recurso Ruby conciso e expressivo.
(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
A distinção principal: .. inclui o final, ... exclui (o terceiro ponto "afasta o final"). Um ponto importante a lembrar.
(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 incluem Enumerable, então suportam each, map, select, etc. — e to_a os materializa em um 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? testam pertencimento eficientemente (especialmente cover?, que apenas verifica os endpoints sem iterar).
# 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 são um recurso útil e expressivo do Ruby usado em muitos cenários comuns, então entendê-los é conhecimento prático valioso.
Eles representam concisamente intervalos (numéricos, alfabéticos) e aparecem em vários contextos frequentes: iteração ((1..5).each — uma forma limpa de fazer loop sobre uma sequência), slicing de arrays e strings (arr[1..3], str[0..4] — extraindo subsequências elegantemente), teste de pertencimento (include?/cover? — verificando se um valor está em um intervalo, com cover? sendo eficiente ao apenas verificar endpoints), e especialmente correspondência em case/when (ramificação limpa baseada em ranges, como classificação por faixas de notas — um padrão comum e legível).
Entender a importante distinção .. (inclusivo) vs ... (exclusivo) é necessário para usar ranges corretamente (e é um ponto comum de confusão).
Saber que ranges incluem Enumerable (então suportam map/select/etc.), como usá-los para iteração, slicing, pertencimento e correspondência em case, e recursos modernos (ranges infinitos/sem início) cobre os usos práticos.
Como ranges aparecem frequentemente em Ruby idiomático (iteração, slicing, condicionais baseados em ranges, validação de faixas de valores), e como são uma forma concisa e expressiva de lidar com intervalos, entender ranges — sua sintaxe (inclusivo vs exclusivo), métodos e usos comuns (iteração, slicing, pertencimento, correspondência em case) — é conhecimento útil e praticamente relevante para escrever Ruby limpo e idiomático que lida com sequências e intervalos elegantemente.