Array zu Hash Ruby

Okay, hier ist der Deal, ich habe lange gegoogelt, um eine Lösung dafür zu finden, und obwohl es viele gibt, scheinen sie nicht den Job zu machen, den ich suche.

Grundsätzlich habe ich ein Array wie folgt aufgebaut

["item 1", "item 2", "item 3", "item 4"] 

Ich möchte dies in einen Hash konvertieren, damit es so aussieht

{ "item 1" => "item 2", "item 3" => "item 4" }

Das heißt, die Elemente in den "geraden" Indizes sind die Schlüssel und die Elemente in den "ungeraden" Indizes sind die Werte.

Irgendwelche Ideen, wie man das sauber macht? Ich nehme an, eine Brute-Force-Methode wäre, einfach alle geraden Indizes in ein separates Array zu ziehen und sie dann zu durchlaufen, um die Werte hinzuzufügen.

a = ["item 1", "item 2", "item 3", "item 4"]
h = Hash[*a] # => { "item 1" => "item 2", "item 3" => "item 4" }

Das ist es. Der *wird als Splat- Operator bezeichnet.

Eine Einschränkung pro @Mike Lewis (in den Kommentaren): "Seien Sie sehr vorsichtig damit. Ruby erweitert Splats auf dem Stapel. Wenn Sie dies mit einem großen Datensatz tun, müssen Sie damit rechnen, Ihren Stapel auszublasen."

Für die meisten allgemeinen Anwendungsfälle ist diese Methode also großartig. Verwenden Sie jedoch eine andere Methode, wenn Sie die Konvertierung für viele Daten durchführen möchten. Zum Beispiel bietet @ Łukasz Niemier (auch in den Kommentaren) diese Methode für große Datenmengen an:

h = Hash[a.each_slice(2).to_a]

Ruby 2.1.0 hat eine to_hMethode für das Array eingeführt, die genau das tut, was Sie benötigen, wenn Ihr ursprüngliches Array aus Arrays von Schlüssel-Wert-Paaren besteht: http://www.ruby-doc.org/core-2.1.0/Array.html#method -i-to_h .

[[:foo, :bar], [1, 2]].to_h
# => {:foo => :bar, 1 => 2}

Verwenden Sie einfach Hash.[]mit den Werten im Array. Beispielsweise:

arr = [1,2,3,4]
Hash[*arr] #=> gives {1 => 2, 3 => 4}

Oder wenn Sie ein Array von [key, value]Arrays haben, können Sie Folgendes tun:

[[1, 2], [3, 4]].inject({}) do |r, s|
  r.merge!({s[0] => s[1]})
end # => { 1 => 2, 3 => 4 }

Das habe ich gesucht, als ich das gegoogelt habe:

[{a: 1}, {b: 2}].reduce({}) { |h, v| h.merge v } => {:a=>1, :b=>2}

Enumeratorbeinhaltet Enumerable. Da 2.1hat Enumerableauch eine Methode #to_h. Deshalb können wir schreiben:

a = ["item 1", "item 2", "item 3", "item 4"]
a.each_slice(2).to_h
# => {"item 1"=>"item 2", "item 3"=>"item 4"}

Weil #each_slicewir ohne Block Enumeratorund gemäß der obigen Erklärung die #to_hMethode für das EnumeratorObjekt aufrufen können .

Sie können dies für ein einzelnes Array versuchen

irb(main):019:0> a = ["item 1", "item 2", "item 3", "item 4"]
  => ["item 1", "item 2", "item 3", "item 4"]
irb(main):020:0> Hash[*a]
  => {"item 1"=>"item 2", "item 3"=>"item 4"}

für Array von Array

irb(main):022:0> a = [[1, 2], [3, 4]]
  => [[1, 2], [3, 4]]
irb(main):023:0> Hash[*a.flatten]
  => {1=>2, 3=>4}

a = ["item 1", "item 2", "item 3", "item 4"]
Hash[ a.each_slice( 2 ).map { |e| e } ]

oder, wenn Sie hassen Hash[ ... ]:

a.each_slice( 2 ).each_with_object Hash.new do |(k, v), h| h[k] = v end

oder, wenn Sie ein fauler Fan von defekter funktionaler Programmierung sind:

h = a.lazy.each_slice( 2 ).tap { |a|
  break Hash.new { |h, k| h[k] = a.find { |e, _| e == k }[1] }
}
#=> {}
h["item 1"] #=> "item 2"
h["item 3"] #=> "item 4"

Alle Antworten setzen voraus, dass das Startarray eindeutig ist. OP hat nicht angegeben, wie Arrays mit doppelten Einträgen behandelt werden sollen, die zu doppelten Schlüsseln führen.

Schauen wir uns an:

a = ["item 1", "item 2", "item 3", "item 4", "item 1", "item 5"]

Sie werden die verlieren item 1 => item 2Paar , wie es überschriebene bij ist item 1 => item 5:

Hash[*a]
=> {"item 1"=>"item 5", "item 3"=>"item 4"}

Alle Methoden, einschließlich des reduce(&:merge!)Ergebnisses, führen zum gleichen Entfernen.

Es könnte jedoch sein, dass dies genau das ist, was Sie erwarten. In anderen Fällen möchten Sie wahrscheinlich Arraystattdessen ein Ergebnis mit einem for-Wert erhalten:

{"item 1"=>["item 2", "item 5"], "item 3"=>["item 4"]}

Der naive Weg wäre, eine Hilfsvariable zu erstellen, einen Hash mit einem Standardwert, und diesen dann in eine Schleife zu füllen:

result = Hash.new {|hash, k| hash[k] = [] } # Hash.new with block defines unique defaults.
a.each_slice(2) {|k,v| result[k] << v }
a
=> {"item 1"=>["item 2", "item 5"], "item 3"=>["item 4"]}

Es mag möglich sein, oben in einer Zeile zu verwenden assocund reducezu tun, aber es wird viel schwieriger, darüber nachzudenken und zu lesen.