Matrice per Hash Ruby

Okay, quindi ecco il patto, ho cercato su Google per anni per trovare una soluzione a questo e mentre ce ne sono molti là fuori, sembra che non facciano il lavoro che sto cercando.

Fondamentalmente ho un array strutturato in questo modo

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

Voglio convertirlo in un hash in modo che assomigli a questo

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

cioè gli elementi che si trovano sugli indici "pari" sono le chiavi e gli elementi sugli indici "dispari" sono i valori.

Qualche idea su come farlo in modo pulito? Suppongo che un metodo di forza bruta sarebbe quello di estrarre tutti gli indici pari in un array separato e quindi circondarli per aggiungere i valori.

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

Questo è tutto. Si *chiama operatore splat .

Un avvertimento per @Mike Lewis (nei commenti): "Stai molto attento con questo. Ruby espande gli splat nello stack. Se lo fai con un set di dati di grandi dimensioni, aspettati di espellere lo stack."

Quindi, per la maggior parte dei casi d'uso generali questo metodo è ottimo, ma usa un metodo diverso se vuoi fare la conversione su molti dati. Ad esempio, @ Łukasz Niemier (anche nei commenti) offre questo metodo per grandi set di dati:

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

Ruby 2.1.0 ha introdotto un to_hmetodo sull'array che fa ciò che è necessario se l'array originale è costituito da array di coppie chiave-valore: 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}

Basta usare Hash.[]con i valori nella matrice. Per esempio:

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

Oppure, se disponi di una matrice di [key, value]array, puoi fare:

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

Questo è quello che stavo cercando quando cercavo su Google:

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

Enumeratorinclude Enumerable. Da allora 2.1, Enumerableha anche un metodo #to_h. Ecco perché, possiamo scrivere: -

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

Perché #each_slicesenza blocco ci dà Enumerator, e secondo la spiegazione sopra, possiamo chiamare il #to_hmetodo Enumeratorsull'oggetto.

Potresti provare così, per singolo array

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

per array di 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 } ]

o, se odi Hash[ ... ]:

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

o, se sei un fan pigro della programmazione funzionale non funzionante:

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"

Tutte le risposte presuppongono che l'array iniziale sia unico. OP non ha specificato come gestire le matrici con voci duplicate, risultando in chiavi duplicate.

Guardiamo:

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

Perderai la item 1 => item 2coppia poiché viene ignorata item 1 => item 5:

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

Tutti i metodi, incluso il reduce(&:merge!) risultato nella stessa rimozione.

Potrebbe essere che questo è esattamente quello che ti aspetti, però. Ma in altri casi, probabilmente vorrai ottenere un risultato con un Arrayvalore for:

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

Il modo ingenuo sarebbe quello di creare una variabile helper, un hash che ha un valore predefinito, e quindi riempirlo in un ciclo:

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

Potrebbe essere possibile usare assoce reducefare sopra in una riga, ma diventa molto più difficile ragionare e leggere.