Wie ändere ich Hash-Werte?

Ich möchte jeden valuein einem Hash durch ersetzen value.some_method.

Zum Beispiel für einen einfachen Hash:

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

Jeder Wert sollte .upcased sein, also sieht es so aus:

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

Ich habe es versucht #collectund #mapbekomme immer nur Arrays zurück. Gibt es eine elegante Möglichkeit, dies zu tun?

AKTUALISIEREN

Verdammt, ich habe vergessen: Der Hash befindet sich in einer Instanzvariablen, die nicht geändert werden sollte. Ich benötige einen neuen Hash mit den geänderten Werten, möchte diese Variable jedoch nicht explizit definieren und dann den durchlaufenden Hash durchlaufen. Etwas wie:

new_hash = hash.magic{ ... }

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

oder, wenn Sie es lieber zerstörungsfrei machen und einen neuen Hash zurückgeben möchten, anstatt ihn zu ändern my_hash:

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

Diese letzte Version hat den zusätzlichen Vorteil, dass Sie auch die Schlüssel transformieren können.

Da ruby 2.4.0Sie native Hash#transform_valuesMethode verwenden können:

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

Es gibt auch eine destruktive Hash#transform_values!Version.

Sie können die Werte sammeln und erneut von Array in Hash konvertieren.

So was:

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

Dies wird es tun:

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

Im Gegensatz zum injectVorteil ist, dass Sie den Hash nicht erneut innerhalb des Blocks zurückgeben müssen.

Versuchen Sie diese Funktion:

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

Dafür gibt es in ActiveSupport v4.2.0 eine Methode . Es wird aufgerufen transform_valuesund führt im Grunde nur einen Block für jedes Schlüssel-Wert-Paar aus.

Da sie es mit einem machen each, gibt es meiner Meinung nach keinen besseren Weg, als sich durchzuschleifen.

hash = {sample: 'gach'}

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

Aktualisieren:

Seit 2.4.0 Rubin können Sie nativ nutzen #transform_valuesund #transform_values!.

Möglicherweise möchten Sie noch einen Schritt weiter gehen und dies für einen verschachtelten Hash tun. Sicherlich passiert dies bei Rails-Projekten ziemlich oft.

Hier ist ein Code, um sicherzustellen, dass ein Parameter-Hash in UTF-8 enthalten ist:

  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  

Ich mache so etwas:

new_hash = Hash [* original_hash.collect {| Schlüssel, Wert | [Schlüssel, Wert + 1]}. abflachen]

Dies bietet Ihnen die Möglichkeit, den Schlüssel oder Wert auch über einen beliebigen Ausdruck zu transformieren (und dies ist natürlich zerstörungsfrei).

Ruby hat die tapMethode ( 1.8.7 , 1.9.3 und 2.1.0 ), die für solche Dinge sehr nützlich ist.

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"}

Schienen-spezifisch

Falls jemand muss nur anrufen to_sMethode der Werte für jeden und ist mit Rails nicht 4.2 (einschließlich transform_valuesVerfahren Link ), können Sie folgendes tun:

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"}

Hinweis: Die Verwendung der 'json'-Bibliothek ist erforderlich.

Hinweis 2: Dadurch werden Schlüssel auch in Zeichenfolgen umgewandelt

Wenn Sie wissen, dass die Werte Zeichenfolgen sind, können Sie im Zyklus die Ersetzungsmethode für sie aufrufen : Auf diese Weise ändern Sie den Wert.

Obwohl dies auf den Fall beschränkt ist, in dem die Werte Zeichenfolgen sind und daher die Frage nicht vollständig beantworten, dachte ich, dass es für jemanden nützlich sein kann.

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"}