Range.to_a / include? / cover? / each

# Creating a Range object.
(start..stop)    # Range from start to stop, inclusive (includes the end).
(start...stop)   # Range from start to stop, exclusive (excludes the end).

# Convert to an array.
range.to_a

# Check whether a value is included (compares each element).
range.include?(value)
range.member?(value)  # Alias for include?

# Check whether a value falls within the range (uses comparison operators, faster).
range.cover?(value)

# Return the first or last element.
range.first
range.first(n)  # Returns the first n elements as an array.
range.last
range.last(n)   # Returns the last n elements as an array.

# Iterate over each element.
range.each { |element| process }

# Create Range objects.
integer_range = (1..5)
exclusive_range = (1...5)

# Convert to an array with to_a.
puts integer_range.to_a.inspect   # [1, 2, 3, 4, 5]
puts exclusive_range.to_a.inspect # [1, 2, 3, 4] (5 is not included)

# Ranges also work with letters.
puts ("a".."e").to_a.inspect  # ["a", "b", "c", "d", "e"]

# Check membership with include?.
puts (1..10).include?(5)   # true
puts (1..10).include?(11)  # false

# cover? uses comparison operators (also works with floating-point values).
puts (1..10).cover?(5.5)     # true (include? may return false in this case)
puts ("a".."z").cover?("m")  # true

# Loop with each.
(1..3).each { |i| print "#{i} " }
puts  # 1 2 3

# first / last.
puts (1..10).first              # 1
puts (1..10).first(3).inspect   # [1, 2, 3]
puts (1..10).last               # 10
puts (1..10).last(3).inspect    # [8, 9, 10]

Ruby Range objects come in two forms: .. (inclusive end) and ... (exclusive end). You can create a range from any object that includes the Comparable module, not just integers — strings and dates work too.

Be aware of the difference between include? and cover?. Because include? compares each element in sequence, it may not behave as expected for floating-point values or dates between discrete steps. cover?, on the other hand, uses only the comparison operator (<=>), making it faster and well-suited for checking continuous value ranges.

Calling last on an exclusive range (...) returns the end value itself, not the element just before it. This can be confusing, so be careful.

For aggregation operations on ranges, see range.min / max / sum / step.