Ruby: Shortest/most idiomatic way of determining whether a variable is any one of a list of values

Question

This seems a ridiculously simple question to be asking, but what's the shortest/most idiomatic way of rewriting this in Ruby?

if variable == :a or variable == :b or variable == :c or variable == :d # etc.

I've previously seen this solution:

if [:a, :b, :c, :d].include? variable

but this isn't always functionally equivalent - I believe Array#include? actually looks to see if the variable object is contained in the list; it doesn't take into account that the object may implement its own equality test with def ==(other).

[EDIT: As observed by helpful commentators below, that explanation isn't correct. #include? does use == but it uses the == method of the items in the array - in my example, the symbols - rather than the == method of variable. That explains why it's not equivalent to my first code example.]

(Take, for example, Rails' Mime::Type implementation: request.format == :html may return true, but [:html].include?(request.format) will return false, as request.format is an instance of Mime::Type, not a symbol.)

The best I have so far is:

if [:a, :b, :c, :d].select {|f| variable == f}.any?

but it seems somewhat cumbersome to me. Any better suggestions?

Answer 1

I've always used your second example, if [:a, :b, :c, :d].include? variable. While this does present some problems with classes that overwrite ==, it's perfectly fine in most situations I've needed it (usually checking against symbols).

Answer 2

How about:

 if [:a, :b, :c, :d].index variable

Answer 3

What you are really doing is seeing if variable is a member of the set [:a,:b,:c,:d] so semantically that maps to the include? method. The problem you encounter is due to the duck typing nature of ruby so if you want to get around that why not first convert to a symbol:

if [:a, :b, :c, :d].include? variable.to_sym

Answer 4

It looks like Array#include? does use ==.

>> class AString < String
>>   def ==(other)
>>     self[0] == other[0]
>>   end
>> end

>> asdf = AString.new "asdfg"
=> "asdfg"
>> b = AString.new 'aer'
=> "aer"

>> asdf == b
=> true

>> [asdf].include? b
=> true

Array#include? documentation also explains this: http://ruby-doc.org/core/classes/Array.html#M002203

Answer 5

Actually, #include? does use ==. The problem arises from the fact that if you do [:a].include? foo, it checks :a == foo, not foo == :a. That is, it uses the == method defined on the objects in the Array, not the variable. Therefore you can use it so long as you make sure the objects in the array have a proper == method.

In cases where that won't work, you can simplify your statement by removing the select statement and passing the block directly to any:

if [:a, :b, :c, :d].any? {|f| variable == f}