Cambiar cada valor en un hash en Ruby

Quiero cambiar cada valor en un hash para agregar '%' antes y después del valor para

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

debe cambiarse a

{ :a=>'%a%' , :b=>'%b%' }

¿Cuál es la mejor manera de hacer esto?

Si desea que las cadenas en sí mismas muten en su lugar (posiblemente y deseablemente afecten otras referencias a los mismos objetos de cadena):

# Two ways to achieve the same result (any Ruby version)
my_hash.each{ |_,str| str.gsub! /^|$/, '%' }
my_hash.each{ |_,str| str.replace "%#{str}%" }

Si desea que el hash cambie en su lugar, pero no desea afectar las cadenas (desea que obtenga nuevas cadenas):

# Two ways to achieve the same result (any Ruby version)
my_hash.each{ |key,str| my_hash[key] = "%#{str}%" }
my_hash.inject(my_hash){ |h,(k,str)| h[k]="%#{str}%"; h }

Si quieres un nuevo hash:

# Ruby 1.8.6+
new_hash = Hash[*my_hash.map{|k,str| [k,"%#{str}%"] }.flatten]

# Ruby 1.8.7+
new_hash = Hash[my_hash.map{|k,str| [k,"%#{str}%"] } ]

En Ruby 2.1 y superior puedes hacer

{ a: 'a', b: 'b' }.map { |k, str| [k, "%#{str}%"] }.to_h

Ruby 2.4 introdujo el método Hash#transform_values!, que puedes usar.

{ :a=>'a' , :b=>'b' }.transform_values! { |v| "%#{v}%" }
# => {:a=>"%a%", :b=>"%b%"} 

La mejor manera de modificar los valores de un Hash en su lugar es

hash.update(hash){ |_,v| "%#{v}%" }

Menos código e intención clara. También más rápido porque no se asignan objetos nuevos más allá de los valores que se deben cambiar.

Un poco más legible, mapa una matriz de hashes de un solo elemento y reduceeso conmerge

the_hash.map{ |key,value| {key => "%#{value}%"} }.reduce(:merge)

Hay un nuevo método 'Rails way' para esta tarea :) http://api.rubyonrails.org/classes/Hash.html#method-i-transform_values

Un método que no introduce efectos secundarios al original:

h = {:a => 'a', :b => 'b'}
h2 = Hash[h.map {|k,v| [k, '%' + v + '%']}]

El mapa Hash # también puede ser una lectura interesante, ya que explica por qué el Hash.mapno devuelve un Hash (razón por la cual la matriz resultante de[key,value] pares se convierte en un nuevo Hash) y proporciona enfoques alternativos para el mismo patrón general.

Feliz codificación

[Descargo de responsabilidad: no estoy seguro si la Hash.mapsemántica cambia en Ruby 2.x]

my_hash.each do |key, value|
  my_hash[key] = "%#{value}%"
end

Hash.merge! es la solución más limpia

o = { a: 'a', b: 'b' }
o.merge!(o) { |key, value| "%#{ value }%" }

puts o.inspect
> { :a => "%a%", :b => "%b%" }

Después de probarlo con RSpec así:

describe Hash do
  describe :map_values do
    it 'should map the values' do
      expect({:a => 2, :b => 3}.map_values { |x| x ** 2 }).to eq({:a => 4, :b => 9})
    end
  end
end

Puede implementar Hash # map_values ​​de la siguiente manera:

class Hash
  def map_values
    Hash[map { |k, v| [k, yield(v)] }]
  end
end

La función se puede usar así:

{:a=>'a' , :b=>'b'}.map_values { |v| "%#{v}%" }
# {:a=>"%a%", :b=>"%b%"}

Si tiene curiosidad por saber qué variante in situ es la más rápida, aquí está:

Calculating -------------------------------------
inplace transform_values! 1.265k (± 0.7%) i/s -      6.426k in   5.080305s
      inplace update      1.300k (± 2.7%) i/s -      6.579k in   5.065925s
  inplace map reduce    281.367  (± 1.1%) i/s -      1.431k in   5.086477s
      inplace merge!      1.305k (± 0.4%) i/s -      6.630k in   5.080751s
        inplace each      1.073k (± 0.7%) i/s -      5.457k in   5.084044s
      inplace inject    697.178  (± 0.9%) i/s -      3.519k in   5.047857s