Como alterar os valores de hash?

Eu gostaria de substituir cada valueum com um hash value.some_method.

Por exemplo, para um hash simples:

{"a" => "b", "c" => "d"}` 

todo valor deve ser .upcased, para que se pareça com:

{"a" => "B", "c" => "D"}

Eu tentei #collecte #mapsempre recuperei as matrizes. Existe uma maneira elegante de fazer isso?

ATUALIZAR

Porra, eu esqueci: O hash está em uma variável de instância que não deve ser alterada. Eu preciso de um novo hash com os valores alterados, mas preferiria não definir essa variável explicitamente e fazer um loop sobre o hash que a preenchia. Algo como:

new_hash = hash.magic{ ... }

my_hash.each { |k, v| my_hash[k] = v.upcase } 

ou, se você preferir fazê-lo de forma não destrutiva e retornar um novo hash em vez de modificar my_hash:

a_new_hash = my_hash.inject({}) { |h, (k, v)| h[k] = v.upcase; h } 

Esta última versão possui o benefício adicional de que você também pode transformar as chaves.

Desde que ruby 2.4.0você pode usar o Hash#transform_valuesmétodo nativo :

hash = {"a" => "b", "c" => "d"}
new_hash = hash.transform_values(&:upcase)
# => {"a" => "B", "c" => "D"}

Há também uma Hash#transform_values!versão destrutiva .

Você pode coletar os valores e convertê-lo de Matriz em Hash novamente.

Como isso:

config = Hash[ config.collect {|k,v| [k, v.upcase] } ]

Isso fará isso:

my_hash.each_with_object({}) { |(key, value), hash| hash[key] = value.upcase }

Em oposição à injectvantagem, você não precisa devolver o hash novamente dentro do bloco.

Tente esta função:

h = {"a" => "b", "c" => "d"}
h.each{|i,j| j.upcase!} # now contains {"a" => "B", "c" => "D"}.

Há um método para isso no ActiveSupport v4.2.0. É chamado transform_valuese basicamente apenas executa um bloco para cada par de valores-chave.

Já que eles estão fazendo isso com um each, acho que não há maneira melhor do que fazer um loop.

hash = {sample: 'gach'}

result = {}
hash.each do |key, value|
  result[key] = do_stuff(value)
end

Atualizar:

Desde o Ruby 2.4.0, você pode usar nativamente #transform_valuese #transform_values!.

Você pode dar um passo adiante e fazer isso em um hash aninhado. Certamente isso acontece com os projetos Rails.

Aqui está um código para garantir que um hash de params esteja no UTF-8:

  def convert_hash hash
    hash.inject({}) do |h,(k,v)|
      if v.kind_of? String
        h[k] = to_utf8(v) 
      else
        h[k] = convert_hash(v)
      end
      h
    end      
  end    

  # Iconv UTF-8 helper
  # Converts strings into valid UTF-8
  #
  # @param [String] untrusted_string the string to convert to UTF-8
  # @return [String] your string in UTF-8
  def to_utf8 untrusted_string=""
    ic = Iconv.new('UTF-8//IGNORE', 'UTF-8')
    ic.iconv(untrusted_string + ' ')[0..-2]
  end  

Eu faço algo assim:

new_hash = Hash [* original_hash.collect {| chave, valor | [chave, valor + 1]}. achatar]

Isso fornece a você as facilidades para transformar a chave ou o valor por meio de qualquer expressão também (e é não destrutivo, é claro).

Ruby tem o tapmétodo ( 1.8.7 , 1.9.3 e 2.1.0 ) que é muito útil para coisas como esta.

original_hash = { :a => 'a', :b => 'b' }
original_hash.clone.tap{ |h| h.each{ |k,v| h[k] = v.upcase } }
# => {:a=>"A", :b=>"B"}
original_hash # => {:a=>"a", :b=>"b"}

Rails-specific

Caso alguém precise chamar o to_smétodo para cada um dos valores e não esteja usando o Rails 4.2 (que inclui o link dotransform_values método ), você pode fazer o seguinte:

original_hash = { :a => 'a', :b => BigDecimal('23.4') }
#=> {:a=>"a", :b=>#<BigDecimal:5c03a00,'0.234E2',18(18)>}
JSON(original_hash.to_json)
#=> {"a"=>"a", "b"=>"23.4"}

Nota: O uso da biblioteca 'json' é necessário.

Nota 2: Isso também transformará chaves em strings

Se você souber que os valores são cadeias, você pode chamar o método de substituição neles enquanto estiver no ciclo: dessa forma, você alterará o valor.

Embora isso seja limitado ao caso em que os valores são cadeias de caracteres e, portanto, não responde totalmente à pergunta, achei que poderia ser útil a alguém.

new_hash = old_hash.merge(old_hash) do |_key, value, _value|
             value.upcase
           end

# old_hash = {"a" => "b", "c" => "d"}
# new_hash = {"a" => "B", "c" => "D"}