Share this post!

Ruby Ranges: How Do They Work?

a few months ago /
By Jesus Castello /
5 COMMENTS

Have you ever wondered how ranges work in Ruby?

Even if you haven’t, isn’t it fun to discover how things work under the hood?

That’s exactly what I’m going to show you in this post!

Understanding Ranges

Just as a reminder, this is what a Ruby range looks like:

1

(1..20)

The parenthesis are not necessary to define a Range, but if you want to call methods on your range you will need them (otherwise you are calling the method on the 2nd element of the range, instead of the range itself).

The Range class includes Enumerable, so you get all the powerful iteration methods without having to convert the range into an array.

Range has some useful methods, like the step method.

Example:

1 2	(10..20).step(2).to_a # [10, 12, 14, 16, 18, 20]

Other Range methods to be aware of are: cover? & include?. It would be a mistake to think that they do the same thing, because they don’t.

The include? method just does what you would expect, check for inclusion inside the range. So it would be equivalent to expanding the Range into an Array and checking if something is in there.

But cover? is different, all it does is check against the initial & ending values of the range (begin <= obj <= end), which can yield unexpected results.

Example:

1 2	('a'..'z').include? "cc" # false ('a'..'z').cover? "cc" # true

The cover? example is equivalent to:

1	"a" <= "cc" && "cc" <= "z"

The reason this returns true is that strings are compared character by character. Since “a” comes before “c”, the characters that come after the first “c” don’t matter.

Range Implementation

Ranges are not limited to numbers & letters, you can use any objects as long as they implement the following methods: <=> and succ.

For example, here is a time range:

1

2

3

4

5

6

7

8

9

require 'time'

t1 = DateTime.new

t2 = DateTime.new + 30

next_30_days = t1..t2

# Example use

next_30_days.select(&:friday?).map(&:day)

So how does this work? Let’s take a look at this implementation:

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

def range(a, b)

# if the first element is bigger than the second

# then this isn't a sequential range

return [] if a > b

out = []

# advance until the 2nd element is the same

# as the first one

while a != b

out << a

a = a.next

end

# add last element (inclusive range)

# this also returns the results via implicit return

out << a

end

p range 1, 10

p range 'a', 'z'

I added some comments to help you understand what is going on. The idea is that we keep calling the next method on the first object until it is equal to the second one, the assumption is that they will eventually meet.

Custom Class Ranges

Most of the time you will be using number & character ranges, but it’s still good to know how you can use ranges in a custom class.

Example:

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

class LetterMultiplier

attr_reader :count

include Comparable

def initialize(letter, count)

@letter = letter

@count = count

end

def succ

self.class.new(@letter, @count + 1)

end

def <=>(other)

count <=> other.count

end

end

a = LetterMultiplier.new('w', 2)

b = LetterMultiplier.new('w', 8)

# Print array with all the items in the range

p Array(a..b)

The key here is to make sure that you implement the <=> & succ methods correctly.

If you want to use the include? method you need to include the Comparable module, which adds methods like ==, <, and > (all based on the results of the <=> method).

Conclusion

In this article you have learned how ranges work in Ruby so you can understand them better & implement your own objects that support range operations.

Don’t forget to subscribe to the newsletter below so you don’t miss the next post 🙂

5 comments

rivsc says a few months ago

1 2	(1..9).include? 5.5 => true

Why ?

Jesus Castello says a few months ago

Good question! The answer is probably this bit from the documentation.

“If begin and end are numeric, comparison is done according to the magnitude of the values.”

http://ruby-doc.org/core-2.2.0/Range.html#method-i-include-3F

Hua says a few months ago

From the source:

1

2

3

4

5

6

7

8

9

10

if (r_le(beg, val)) {

if (EXCL(range)) {

if (r_lt(val, end))

return Qtrue;

}

else {

if (r_le(val, end))

return Qtrue;

}

}

We can understand why.

Demba Siby says a few months ago

‘The reason this returns false is that strings are compared character by character. Since “a” comes before “c”, the characters that come after the “c” don’t matter.’

You mean the reason this returns true?

Jesus Castello says a few months ago

I fixed that. Thank you 🙂

Comments are closed

Popular posts

11 Ruby Tricks You Haven’t Seen Before

Jan 18, 2016

The Ultimate Guide to Blocks, Procs & Lambdas

Feb 02, 2016

Building Your Own Linux Tools with Ruby: A Practical Guide

Jun 27, 2016

Mastering Ruby Arrays

May 06, 2015