I want to write the conditions as such, but it's too long. How can I make it more simple?
if A
~~~
elsif B == b || B == c || B == d || B == e <-- This part is too long.
~~~
else
~~~
end
I thought it could be written as below, but it gave me an error, when I tried it on rails console.
elsif B == (b || c || d || e)
if B == b || B == c || B == d || B == e
can be written as
if [b, c, d, e].include?(B)
[EDIT] (Thanks to the comment from Sergio Tulentsev) This is only relevant for longer arrays, more than about 10 elements, not in the exact case described by the OP. I include this answer for other users who may have longer arrays or lists of comparisons. [/EDIT]
If speed is also an issue: use a Set, which has a faster include? compared to Array:
# at the top, load this standard library (comes with Ruby):
require 'set'
# ...
if [b, c, d, e].to_set.include?(B)
SEE ALSO:
Array.include? is relatively slow. For lookups, use a set instead of a hash: https://stackoverflow.com/a/411164/967621
Speed comparisons for arrays, sets, and hashes, with benchmarks: Advantages of Set in ruby
Set#include? is much faster than Array#include? – a set can answer the question in just one step whereas an array needs to iterate all elements. But to_set needs to hash each element and therefore iterates all elements too. Therefore the question is not how many elements there are in the array but how often you will need to call includes? on the collection? For a small number of include? calls an array will be faster because you save the to_set call which is quite expensive. For a bigger number, a set will win.
elsif [b, c, d, e].include? BThis also depends what you mean by 'making more simple?' It might be that writing a case statement is better on a compiled level, etc....elsif; case(B); when b,c,d,e; ~~~~~; end; else; ~~~~; end;