Un Rango representa un intervalo de valores — (1..10) para números, ('a'..'z') para letras, etc. Los rangos son objetos con métodos útiles, utilizados para iteración, corte, pruebas de pertenencia y coincidencia en case. Son una característica concisa y expresiva de Ruby.
(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 distinción clave: .. incluye el final, ... lo excluye (el tercer punto "aleja el final"). Un punto importante a recordar.
(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]
Los rangos incluyen Enumerable, por lo que soportan each, map, select, etc. — y to_a los materializa en 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? prueban pertenencia eficientemente (especialmente cover?, que solo verifica los extremos sin 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)
Los rangos son una característica útil y expresiva de Ruby utilizada en muchos escenarios comunes, por lo que comprenderlos es conocimiento valioso del día a día.
Representan concisamente intervalos (numéricos, alfabéticos) y aparecen en varios contextos frecuentes: iteración ((1..5).each — una forma limpia de iterar sobre una secuencia), corte de arrays y strings (arr[1..3], str[0..4] — extrayendo subsecuencias elegantemente), prueba de pertenencia (include?/cover? — verificando si un valor cae en un intervalo, siendo cover? eficiente al solo verificar los extremos), y especialmente coincidencia en case/when (ramificación limpia basada en rangos, como calificación por rangos de puntuación — un patrón común y legible).
Comprender la importante distinción .. (inclusivo) vs ... (exclusivo) es necesario para usar rangos correctamente (y es un punto común de confusión).
Saber que los rangos incluyen Enumerable (por lo que soportan map/select/etc.), cómo usarlos para iteración, corte, pertenencia y coincidencia en case, y características modernas (rangos infinitos/sin inicio) cubre los usos prácticos.
Ya que los rangos aparecen frecuentemente en Ruby idiomático (iteración, corte, condicionales basados en rangos, validación de rangos de valores), y ya que son una forma concisa y expresiva de manejar intervalos, comprender rangos — su sintaxis (inclusiva vs exclusiva), métodos y usos comunes (iteración, corte, pertenencia, coincidencia en case) — es conocimiento útil y práctico relevante para escribir Ruby limpio e idiomático que maneje secuencias e intervalos elegantemente.