Clave/valor condicional en un hash de ruby ​​

Question

¿Hay alguna manera agradable (una línea) de escribir un hash en rubí con alguna entrada solo allí si se cumple una condición? Pensé en

{:a => 'a', :b => ('b' if condition)} 

pero que deja :b == nil si no se cumple la condición. Me doy cuenta de que esto podría hacerse fácilmente en dos líneas más o menos, pero sería mucho mejor en una línea (por ejemplo, al pasar el hash a una función).

¿Me falta (todavía) otra de las increíbles características de ruby ​​aquí? ;)

Answer 1

Primero puede crear el hash con la tecla => nil para cuando la condición no se cumple, y luego eliminar aquellos pares donde el valor es nulo. Por ejemplo:

{ :a => 'a', :b => ('b' if cond) }.delete_if{ |k,v| v.nil? } 

rendimientos, para cond == true:

{:b=>"b", :a=>"a"} 

y para cond == false

{:a=>"a"} 

ACTUALIZACIÓN

Esto es equivalente - una un poco más conciso y en rubí notación 1.9.3:

{ a: 'a', b: ('b' if cond) }.reject{ |k,v| v.nil? } 

Answer 2

Los interesados ​​en conocer otras respuestas, pero esto es lo mejor que se me ocurre de una sola línea (también estoy muy malos en una sola línea: P)

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

Answer 3

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

Esto se basa en el hecho de que *nil se expande a vacío en ruby ​​1.9. En Ruby 1.8, puede que tenga que hacer:

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

o

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

Answer 4

Si tiene varias condiciones y la lógica que otros tendrán que comprender más tarde, entonces le sugiero que esto no es un buen candidato para una 1 revestimiento. Tendría más sentido crear correctamente su hash en función de la lógica requerida.

Answer 5

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

o incluso

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

para añadir más condiciones simples

Answer 6

hash, hash_new = {:a => ['a', true], :b => ['b', false]}, {} 
hash.each_pair{|k,v| hash_new[k] = v[1] ? v : nil } 
puts hash_new 

Answer 7

Ésta es agradable para múltiples condicionales.

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

Tenga en cuenta que elegí nil como la clave "basura", que se elimina cuando haya terminado. Si alguna vez tiene que almacenar un valor real con una clave nula, basta con cambiar las condicionales de la tienda para algo como:

(condition_b ? :b : garbage_key) 

a continuación, eliminar (garbage_key) al final.

Esta solución también mantendrá intactos los valores nulos existentes, p. si tuvieras: a => nil en el hash original, no será eliminado.

Answer 8

De Ruby 1.9+, si quieres construir un hash basado en condicionales puedes usar tap, que es mi nueva cosa favorita. Esto rompe en varias líneas, pero en mi humilde opinión es más legible:

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

Answer 9

En Los Carriles:

{a: 'asd', b: nil}.compact 
=> {:a=>"asd"} 

Answer 10

Mi solución de una sola línea:

{:a => 'a'}.tap { |h| h.merge!(:b => 'b') if condition } 

Answer 11

en Ruby 2.0 hay un doble splat operador (**) para hashes (y parámetros de palabra clave) por analogía al operador splat anterior (*) para matrices (y parámetros posicionales). Así que se podría decir:

{a: 'b', **(condition ? {b: 'b'} : {})} 

Answer 12

Hay una gran cantidad de soluciones inteligentes de aquí, pero la OMI el enfoque más simple y por lo tanto mejor es

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

Va en contra de la solicitud de la OP de hacerlo en dos líneas, pero realmente también lo hacen las otras respuestas que solo parecen ser de una sola línea. Reconozcámoslo, esta es la solución más trivial y es fácil de leer.