只要X为真，则X，否则为Y

Question

Think I'm brain dead. I need a really concise way of writing when X exists (the value for a specified key in a hash), print that value (ie, X), otherwise, print 0. The reason it needs to be concise is because I'm using it in a options for a form_tag , and I'd like to avoid writing a method.

Can't think this through... here's what I've tried:

1. This won't work because it will always return "0": <%= number_field_tag "transaction[][#{thing}]", :quantity, min: 0, placeholder: 0 || @transactionparams["#{thing}"] %> <%= number_field_tag "transaction[][#{thing}]", :quantity, min: 0, placeholder: 0 || @transactionparams["#{thing}"] %>

2. This won't work because whenever @transactionparams doesn't exist, instead of getting 0, I get an error undefined method []' for nil:NilClass <%= number_field_tag "transaction[][#{thing}]", :quantity, min: 0, placeholder: @transactionparams["#{thing}"] %>`

Answer 1

If you're using Ruby 2+, you can take advantage of the fact that nil.to_h is an empty Hash:

v = @transactionparams.to_h[:thing] || 0

You can also take advantage of nil.to_i being zero:

v = @transactionparams.to_h[:thing].to_i

Note that Rails will patch NilClass#to_h to return an empty Hash too so this will work even if you're not in Ruby 2+.

These assume that you're not expecting nil to be a value in the Hash. If you want to allow nil values through then use fetch with a second argument:

v = @transactionparams.to_h.fetch(:thing, 0)

Since you're in Rails, you could throw a try into the mix to swallow up the nil values of the instance variable:

v = @transactionparams.try(:fetch, :thing, 0).to_i

The trailing to_i call is there because nil.try(m) is nil for all m . You could also call #[] explicitly and avoid the second "return this instead of raising an exception" argument to Hash#fetch :

v = @transactionparams.try(:[], :thing).to_i

You can mix and match the above depending on what sorts of values you expect to have in @transactionparams and how specifically you need to handle nil s. I'd probably go with to_h and to_i in most cases:

@transactionparams.to_h[:thing].to_i

I tend to use .to_X methods ( #to_a in particular) to hide nil checks all the time so I would immediately recognize the purpose of to_h and to_i in that expression.

Answer 2

How about a ternary operator?

@transactionparams = {:thing => "foo"}
puts @transactionparams ? @transactionparams[:thing] : 0
@transactionparams = nil 
puts @transactionparams ? @transactionparams[:thing] : 0