Ustalanie, czy zmienna mieści się w zakresie?

Muszę napisać pętlę, która robi coś takiego:

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

Ale do tej pory poszli złymi ścieżkami pod względem składni.

if i. between? (1, 10)
  zrób rzecz 1 
elsif i.between? (11,20)
  zrób coś 2 
...

Użyj ===operatora (lub jego synonimu include?)

if (1..10) === i

Jak powiedział @Baldu, użyj operatora === lub przypadku użycia / kiedy wewnętrznie używa ===:

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

jeśli nadal chcesz używać zakresów ...

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

Zwykle można uzyskać znacznie lepszą wydajność, stosując coś takiego:

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

Możesz użyć
if (1..10).cover? i then thing_1 elsif (11..20).cover? i then thing_2

i według tego testu w Fast Ruby jest szybszy niżinclude?

Nie jest to bezpośrednia odpowiedź na pytanie, ale jeśli wolisz coś przeciwnego do „wewnątrz”:

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

prawdziwe

Bardziej dynamiczna odpowiedź, którą można zbudować w Rubim:

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

Tak więc w tym przypadku „zakresy” są tak naprawdę ogrodzone zerami, aby uchwycić warunki brzegowe.

Na smyczki:

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

# => prawda