web-dev-qa-db-de.com

Wie konvertiere ich einen Ruby-Hash so, dass alle seine Schlüssel Symbole sind?

Ich habe einen Ruby-Hash, der wie folgt aussieht:

{ "id" => "123", "name" => "test" }

Ich möchte es konvertieren in:

{ :id => "123", :name => "test" }
52
ed1t
hash = {"Apple" => "banana", "coconut" => "domino"}
Hash[hash.map{ |k, v| [k.to_sym, v] }]
#=> {:Apple=>"banana", :coconut=>"domino"}

Update:

@mu ist zu kurz: Ich habe Word nicht "rekursiv" gesehen, aber wenn Sie darauf bestehen (zusammen mit dem Schutz vor nicht vorhandenem to_sym, möchten Sie nur daran erinnern, dass in Ruby 1.8 1.to_sym == nil das Spielen mit einigen Tastentypen irreführend sein kann):

hash = {"a" => {"b" => "c"}, "d" => "e", Object.new => "g"}

s2s = 
  lambda do |h| 
    Hash === h ? 
      Hash[
        h.map do |k, v| 
          [k.respond_to?(:to_sym) ? k.to_sym : k, s2s[v]] 
        end 
      ] : h 
  end

s2s[hash] #=> {:d=>"e", #<Object:0x100396ee8>=>"g", :a=>{:b=>"c"}}
66
Victor Moroz

Wenn Sie sich in Rails befinden, haben Sie symbolize_keys :

Gibt einen neuen Hash zurück, wobei alle Schlüssel in Symbole umgewandelt werden, sofern sie auf to_sym antworten.

und symbolize_keys!, der dasselbe tut, aber an Ort und Stelle arbeitet. Wenn Sie sich in Rails befinden, könnten Sie:

hash.symbolize_keys!

Wenn Sie innere Hashes rekursiv symbolisieren möchten, müssen Sie dies wahrscheinlich selbst tun, jedoch mit folgendem Inhalt:

def symbolize_keys_deep!(h)
    h.keys.each do |k|
        ks    = k.to_sym
        h[ks] = h.delete k
        symbolize_keys_deep! h[ks] if h[ks].kind_of? Hash
    end
end

Möglicherweise möchten Sie mit dem kind_of? Hash spielen, um sich Ihren spezifischen Umständen anzupassen. Die Verwendung von respond_to? :keys ist möglicherweise sinnvoller. Und wenn Sie Schlüssel zulassen möchten, die to_sym nicht verstehen, dann:

def symbolize_keys_deep!(h)
    h.keys.each do |k|
        ks    = k.respond_to?(:to_sym) ? k.to_sym : k
        h[ks] = h.delete k # Preserve order even when k == ks
        symbolize_keys_deep! h[ks] if h[ks].kind_of? Hash
    end
end

Beachten Sie, dass h[ks] = h.delete k den Inhalt des Hashs nicht ändert, wenn k == ks, aber die Reihenfolge beibehalten wird, wenn Sie Ruby 1.9+ verwenden. Sie können auch den [(key.to_sym rescue key) || key]-Ansatz verwenden, den Rails in ihrem symbolize_keys! verwendet, aber ich denke, das ist ein Missbrauch des Ausnahmebehandlungssystems.

Der zweite symbolize_keys_deep! dreht sich um:

{ 'a' => 'b', 'c' => { 'd' => { 'e' => 'f' }, 'g' => 'h' }, ['i'] => 'j' }

das sehr gut finden:

{ :a => 'b', :c => { :d => { :e => 'f' }, :g => 'h' }, ['i'] => 'j' }

Sie könnten eine der beiden Versionen von symbolize_keys_deep! in Hash einficken, wenn Sie es wirklich wollten, aber ich halte mich normalerweise an dem Affen-Patching, es sei denn, ich habe gute Gründe dafür.

53
mu is too short

Wenn Sie Rails> = 4 verwenden, können Sie Folgendes verwenden:

hash.deep_symbolize_keys
hash.deep_symbolize_keys!

oder

hash.deep_stringify_keys
hash.deep_stringify_keys!

siehe http://apidock.com/Rails/v4.2.1/Hash/deep_symbolize_keys

39
MRifat

Für den Fall, dass Sie JSON analysieren, können Sie in json docs die Option hinzufügen, um die Schlüssel beim Analysieren zu symbolisieren:

hash = JSON.parse(json_data, symbolize_names: true)
18
Alex Popov

Victor Moroz gab eine schöne Antwort für den einfachen rekursiven Fall, verarbeitet jedoch keine Hashes, die in verschachtelten Arrays verschachtelt sind:

hash = { "a" => [{ "b" => "c" }] }
s2s[hash] #=> {:a=>[{"b"=>"c"}]}

Wenn Sie Hashes innerhalb von Arrays innerhalb von Hashes unterstützen müssen, möchten Sie Folgendes:

def recursive_symbolize_keys(h)
  case h
  when Hash
    Hash[
      h.map do |k, v|
        [ k.respond_to?(:to_sym) ? k.to_sym : k, recursive_symbolize_keys(v) ]
      end
    ]
  when Enumerable
    h.map { |v| recursive_symbolize_keys(v) }
  else
    h
  end
end
10
pje

Versuche dies:

hash = {"Apple" => "banana", "coconut" => "domino"}
 # => {"Apple"=>"banana", "coconut"=>"domino"} 

hash.tap do |h|
  h.keys.each { |k| h[k.to_sym] = h.delete(k) }
end
 # => {:Apple=>"banana", :coconut=>"domino"} 

Dies durchläuft die Schlüssel und es löscht für jeden Schlüssel den stringifizierten Schlüssel und ordnet seinen Wert dem symbolisierten Schlüssel zu.

5
John Feminella

Ab Ruby 2.5 können Sie die transform_key-Methode verwenden: https://docs.Ruby-lang.org/de/trunk/Hash.html#method-i-transform_keys

In Ihrem Fall wäre also:

h = { "id" => "123", "name" => "test" }
h.transform_keys!(&:to_sym)      #=> {:id=>"123", :name=>"test"}

Hinweis: Dieselben Methoden stehen auch für Ruby on Rails zur Verfügung.

4
Paulo Fidalgo

Wenn Sie Rails verwenden (oder nur aktive Unterstützung):

{ "id" => "123", "name" => "test" }.symbolize_keys
4
bonkydog

Ruby-Einzeiler, der schneller ist als die gewählte Antwort

hash = {"Apple" => "banana", "coconut" => "domino"}
#=> {"Apple"=>"banana", "coconut"=>"domino"}

hash.inject({}){|h,(k,v)| h[k.intern] = v; h}
#=> {:Apple=>"banana", :coconut=>"domino"}

Benchmark-Ergebnisse

n = 100000

Benchmark.bm do |bm|
  bm.report { n.times { hash.inject({}){|h,(k,v)| h[k.intern] = v; h} } }
  bm.report { n.times { Hash[hash.map{ |k, v| [k.to_sym, v] }] } }
end

# =>       user     system      total        real
# =>   0.100000   0.000000   0.100000 (  0.107940)
# =>   0.120000   0.010000   0.130000 (  0.137966)
4
Chakaitos

Sie können auch die Hash-Ruby-Klasse erweitern, indem Sie eine /lib/hash.rb -Datei hinzufügen:

class Hash
  def symbolize_keys_deep!
    new_hash = {}
    keys.each do |k|
      ks    = k.respond_to?(:to_sym) ? k.to_sym : k
      if values_at(k).first.kind_of? Hash or values_at(k).first.kind_of? Array
        new_hash[ks] = values_at(k).first.send(:symbolize_keys_deep!)
      else
        new_hash[ks] = values_at(k).first
      end
    end

    new_hash
  end
end

Wenn Sie sicherstellen möchten, dass Schlüssel von Hashs, die in Arrays innerhalb Ihres übergeordneten Hashs eingeschlossen sind, symbolisiert werden, müssen Sie auch die Array-Klasse erweitern und eine "array.rb" -Datei mit diesem Code erstellen:

class Array
  def symbolize_keys_deep!
    new_ar = []
    self.each do |value|
      new_value = value
      if value.is_a? Hash or value.is_a? Array
        new_value = value.symbolize_keys_deep!
      end
      new_ar << new_value
    end
    new_ar
  end
end

Dies ermöglicht den Aufruf von "symbolize_keys_deep!" auf einer beliebigen Hash-Variablen wie folgt: 

myhash.symbolize_keys_deep!
2

Ich bin parteiisch zu:

irb
Ruby-1.9.2-p290 :001 > hash = {"Apple" => "banana", "coconut" => "domino"}
{
      "Apple" => "banana",
    "coconut" => "domino"
}
Ruby-1.9.2-p290 :002 > hash.inject({}){ |h, (n,v)| h[n.to_sym] = v; h }
{
      :Apple => "banana",
    :coconut => "domino"
}

Das funktioniert, weil wir über den Hash hinweg iterieren und im Nu einen neuen erstellen. Es ist nicht rekursiv, aber man könnte das aus den anderen Antworten herausfinden.

hash.inject({}){ |h, (n,v)| h[n.to_sym] = v; h }
2
the Tin Man

Hier sind meine zwei Cent, 

meine Version von symbolize_keys_deep! verwendet die ursprünglichen symbolize_keys! wird von Rails bereitgestellt und führt einfach einen rekursiven Aufruf von Symbolize Sub-Hashes aus.

  def symbolize_keys_deep!(h)
    h.symbolize_keys!
    h.each do |k, v|
      symbolize_keys_deep!(v) if v.is_a? Hash
    end
  end
1
don giulio

Facets 'Hash # rekey ist ebenfalls erwähnenswert.

Probe:

require 'facets/hash/rekey'
{ "id" => "123", "name" => "test" }.deep_rekey
=> {:id=>"123", :name=>"test"}

Es gibt auch eine rekursive Version:

require 'facets/hash/deep_rekey'
{ "id" => "123", "name" => {"first" => "John", "last" => "Doe" } }.deep_rekey
=> {:id=>"123", :name=>{:first=>"John", :last=>"Doe"}}
1
Sergikon
def symbolize_keys(hash)
   new={}
   hash.map do |key,value|
        if value.is_a?(Hash)
          value = symbolize_keys(value) 
        end
        new[key.to_sym]=value
   end        
   return new

end  
puts symbolize_keys("c"=>{"a"=>2,"k"=>{"e"=>9}})
#{:c=>{:a=>2, :k=>{:e=>9}}}
1
kajal agarwal

Hier ist eine kleine rekursive Funktion, um eine tiefe Symbolisierung der Tasten durchzuführen:

def symbolize_keys(hash)
  Hash[hash.map{|k,v| v.is_a?(Hash) ? [k.to_sym, symbolize_keys(v)] : [k.to_sym, v] }]
end
0
user3250006