Conditional key/value in a ruby hash

Question

Is there a nice (one line) way of writing a hash in ruby with some entry only there if a condition is fulfilled? I thought of

{:a => \'a\', :b => (\'b\         


        

Answer 1

eval("{:a => 'a' #{', :b => \'b\'' if condition }}")

or even

eval("{#{[":a => 'a'", (":b=>'b'" if ax)].compact.join(',')}}")

for more simple add conditions

Answer 2

Hash[:a, 'a', *([:b, 'b'] if condition1), *([:c, 'c'] if condition2)]

This relies on the fact that *nil expands to vacuity in ruby 1.9. In ruby 1.8, you might need to do:

Hash[:a, 'a', *(condition1 ? [:b, 'b'] : []), *(condition2 ? [:c, 'c'] : [])]

or

Hash[:a, 'a', *([:b, 'b'] if condition1).to_a, *([:c, 'c'] if condition2).to_a]

Answer 3

Interested in seeing other answers, but this is the best I can think up of for a one-liner (I'm also notoriously bad at one-liners :P)

{:a => 'a'}.merge( condition ? {:b => 'b'} : {} )

Answer 4

There's a lot of clever solutions in here, but IMO the simplest and therefore best approach is

hash = { a: 'a', b: 'b' }
hash[:c] = 'c' if condition

It goes against the OP's request of doing it in two lines, but really so do the other answers that only appear to be one-liners. Let's face it, this is the most trivial solution and it's easy to read.

Answer 5

From Ruby 1.9+, if you want to build a hash based on conditionals you can use tap, which is my new favourite thing. This breaks it onto multiple lines but is more readable IMHO:

{}.tap do |my_hash| 
  my_hash[:a] = 'a'
  my_hash[:b] = 'b' if condition
end

Answer 6

This one is nice for multiple conditionals.

(
  hash = {:a => 'a'}.tap {|h|
    h.store( *[(:b if condition_b), 'b'] )
    h.store( *[(:c if condition_c), 'c'] )
  }
).delete(nil)

Note that I chose nil as the "garbage" key, which gets deleted when you're done. If you ever need to store a real value with a nil key, just change the store conditionals to something like:

(condition_b ? :b : garbage_key)

then delete(garbage_key) at the end.

This solution will also keep existing nil values intact, e.g. if you had :a => nil in the original hash, it won't be deleted.