Determining if a variable is within range?

Question

I need to write a loop that does something like:

if i (1..10)
  do thing 1
elsif i (11..20)
  do thing 2
elsif i (21..30)
  do thing 3
etc...

But so far have gone down the wrong paths in terms of syntax.

score 320 · Answer 1 · answered Aug 17 '10 at 19:01

320

if i.between?(1, 10)
  do thing 1 
elsif i.between?(11,20)
  do thing 2 
...

answered Aug 17 '10 at 19:01

rogerdpack

62,887
36
269
388

3

This also works for `Date` and `DateTime` objects while `===` does not. – Aditya Jun 04 '12 at 02:23
`i.between?(1..10)` won't work (if it is `..`) I suppose there must be a reason for it – nonopolarity Dec 11 '15 at 23:46
**between?** would need two parameters it would not allow range. – Manish Nagdewani Nov 16 '16 at 13:12
7

is it inclusive or exclusive? – andrewcockerham Aug 29 '17 at 12:01
2

@andrewcockerham Inclusive. `3.between?(1, 3) => true` – Tyler James Young Aug 01 '18 at 22:53

Baldu · Answer 2 · 2009-05-15T20:04:20.557

93

Use the === operator (or its synonym include?)

if (1..10) === i

edited May 15 '09 at 20:04

answered May 15 '09 at 19:52

Baldu

5,714
2
30
19

1

Has the nice benefit of also working with `i` being something else than a number (like `nil`) – Christoffer Klang Jul 24 '12 at 09:45
4

Wouldn't seem like a very efficient solution if the range had been significantly large. – rthbound Nov 25 '13 at 06:49
6

For future reader, the alternative way `if i === (1..10)` won't work – Anwar May 24 '15 at 11:13
@rthbound, why? `(1..10000000000000000)` isn't an array. `(1..10000000000000000) === 5000000000000000` is just doing a "between" test under the hood – John La Rooy Jan 17 '16 at 23:29
1

@Anwar could you explain why it doesn't work the other way? – Govind Rai Feb 19 '17 at 01:14
@GovindRai for a single `i`, the `===` works as equivalent operator, of course `i` is not equal to `(1..10)` range. However, for range, `===` works as `include?` method. – Anwar Feb 19 '17 at 05:33

score 72 · Answer 3 · answered May 15 '09 at 19:55

72

As @Baldu said, use the === operator or use case/when which internally uses === :

case i
when 1..10
  # do thing 1
when 11..20
  # do thing 2
when 21..30
  # do thing 3
etc...

answered May 15 '09 at 19:55

Vincent Robert

35,564
14
82
119

of all the answers, this is also likely the most performant when you have multiple ranges. – xentek Jun 09 '13 at 03:21

score 42 · Answer 4 · answered May 15 '09 at 19:54

42

if you still wanted to use ranges...

def foo(x)
 if (1..10).include?(x)
   puts "1 to 10"
 elsif (11..20).include?(x)
   puts "11 to 20"
 end
end

answered May 15 '09 at 19:54

Tim Hoolihan

12,316
3
41
54

Juan Felipe Rodriguez · Answer 5 · 2017-08-30T13:55:53.663

12

You could use
if (1..10).cover? i then thing_1 elsif (11..20).cover? i then thing_2

and according to this benchmark in Fast Ruby is faster than include?

edited Aug 30 '17 at 13:55

answered Aug 28 '17 at 15:54

Juan Felipe Rodriguez

249
3
7

This is actually a lot faster – Joe Half Face Aug 29 '17 at 09:34

score 10 · Answer 6 · answered May 28 '14 at 21:15

10

You can usually get a lot better performance with something like:

if i >= 21
  # do thing 3
elsif i >= 11
  # do thing 2
elsif i >= 1
  # do thing 1

answered May 28 '14 at 21:15

Brad Werth

17,411
10
63
88

score 6 · Answer 7 · answered Nov 09 '16 at 14:05

6

Not a direct answer to the question, but if you want the opposite to "within":

(2..5).exclude?(7)

true

answered Nov 09 '16 at 14:05

Fellow Stranger

32,129
35
168
232

1

Note that `exclude?` is a [Rails addition](https://apidock.com/rails/Enumerable/exclude%3F). – Jan Klimo Jun 12 '20 at 10:31

score 6 · Answer 8 · answered May 19 '21 at 00:43

If you need the fastest way to do it, use the good old comparing.

require 'benchmark'

i = 5
puts Benchmark.measure { 10000000.times {(1..10).include?(i)} }
puts Benchmark.measure { 10000000.times {i.between?(1, 10)}   }
puts Benchmark.measure { 10000000.times {1 <= i && i <= 10}   }

on my system prints:

0.959171   0.000728   0.959899 (  0.960447)
0.919812   0.001003   0.920815 (  0.921089)
0.340307   0.000000   0.340307 (  0.340358)

As you can see, double comparing is almost 3 times faster than #include? or #between? methods!

score 1 · Answer 9 · answered May 16 '09 at 04:58

A more dynamic answer, which can be built in Ruby:

def select_f_from(collection, point) 
  collection.each do |cutoff, f|
    if point <= cutoff
      return f
    end
  end
  return nil
end

def foo(x)
  collection = [ [ 0, nil ],
                 [ 10, lambda { puts "doing thing 1"} ],
                 [ 20, lambda { puts "doing thing 2"} ],
                 [ 30, lambda { puts "doing thing 3"} ],
                 [ 40, nil ] ]

  f = select_f_from(collection, x)
  f.call if f
end

So, in this case, the "ranges" are really just fenced in with nils in order to catch the boundary conditions.

score -2 · Answer 10 · answered Dec 14 '12 at 11:39

-2

For Strings:

(["GRACE", "WEEKLY", "DAILY5"]).include?("GRACE")

#=>true

answered Dec 14 '12 at 11:39

vidur punj

5,019
4
46
65

Determining if a variable is within range?

10 Answers10

Linked

Related