J'ai besoin d'écrire une boucle qui fait quelque chose comme:
if i (1..10)
do thing 1
elsif i (11..20)
do thing 2
elsif i (21..30)
do thing 3
etc...
Mais jusqu'à présent, nous avons emprunté les mauvais chemins en termes de syntaxe.
si i.entre (1, 10) fait la chose 1 elsif i.a entre? (11,20) fait la chose 2 ...
Utilisez le ===
_ opérateur (ou son synonyme include?
)
if (1..10) === i
Comme @Baldu l'a dit, utilisez l'opérateur === ou le cas d'utilisation/lorsque celui-ci utilise en interne ===:
case i
when 1..10
# do thing 1
when 11..20
# do thing 2
when 21..30
# do thing 3
etc...
si vous vouliez toujours utiliser des gammes ...
def foo(x)
if (1..10).include?(x)
puts "1 to 10"
elsif (11..20).include?(x)
puts "11 to 20"
end
end
Vous pouvez généralement obtenir de bien meilleures performances avec quelque chose comme:
if i >= 21
# do thing 3
elsif i >= 11
# do thing 2
elsif i >= 1
# do thing 1
Vous pourriez utiliserif (1..10).cover? i then thing_1 elsif (11..20).cover? i then thing_2
et selon ce repère dans Fast Ruby est plus rapide que include?
Pas une réponse directe à la question, mais si vous voulez le contraire de "dans":
(2..5).exclude?(7)
vrai
Une réponse plus dynamique, qui peut être construite en 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
Donc, dans ce cas, les "plages" ne sont en réalité que clôturées avec des nils afin de saisir les conditions aux limites.