Determinare se una variabile è compresa nell'intervallo?

Question

Ho bisogno di scrivere un ciclo che fa qualcosa di simile:

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

Ma finora sono andati giù per le strade sbagliate in termini di sintassi.

Answer 1

Utilizzare l'=== operatore (o il suo sinonimo include?)

if (1..10) === i 

Answer 2

se ancora voleva utilizzare gamme ...

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

Answer 3

Come detto @Baldu, utilizzare l'operatore === o 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... 

Answer 4

Una risposta più dinamica, che c un essere costruito 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 

Quindi, in questo caso, gli "intervalli" sono in realtà solo recintato con Nils al fine di catturare le condizioni al contorno.

Answer 5

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

Answer 6

For Strings:

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

# => true

Answer 7

Di solito è possibile ottenere molto meglio delle prestazioni con qualcosa di simile:

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

Answer 8

Non è una risposta diretta alla domanda, ma se si desidera l'opposto a "dentro":

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

vero

Answer 9

Si potrebbe utilizzare
if (1..10).cover? i then thing_1 elsif (11..20).cover? i then thing_2

e secondo questo punto di riferimento nel Fast Ruby è più veloce di include?