Tableau à Hash Ruby

D'accord, voici l'affaire, je cherche depuis des lustres sur Google pour trouver une solution à ce problème et bien qu'il y en ait beaucoup, ils ne semblent pas faire le travail que je recherche.

Fondamentalement, j'ai un tableau structuré comme ça

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

Je veux le convertir en hachage pour qu'il ressemble à ceci

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

c'est-à-dire que les éléments qui sont sur les index «pairs» sont les clés et les éléments sur les index «impairs» sont les valeurs.

Des idées comment faire cela proprement? Je suppose qu'une méthode de force brute consisterait simplement à extraire tous les index pairs dans un tableau séparé, puis à les contourner pour ajouter les valeurs.

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

C'est tout. Le *s'appelle l' opérateur splat .

Une mise en garde par @Mike Lewis (dans les commentaires): "Soyez très prudent avec ceci. Ruby étend les splats sur la pile. Si vous faites cela avec un grand jeu de données, attendez-vous à faire exploser votre pile."

Donc, pour la plupart des cas d'utilisation généraux, cette méthode est excellente, mais utilisez une méthode différente si vous souhaitez effectuer la conversion sur beaucoup de données. Par exemple, @ Łukasz Niemier (également dans les commentaires) propose cette méthode pour les grands ensembles de données:

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

Ruby 2.1.0 a introduit une to_hméthode sur Array qui fait ce dont vous avez besoin si votre tableau d'origine se compose de tableaux de paires clé-valeur: http://www.ruby-doc.org/core-2.1.0/Array.html#method -i-vers_h .

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

Utilisez simplement Hash.[]avec les valeurs du tableau. Par exemple:

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

Ou si vous avez un tableau de [key, value]tableaux, vous pouvez faire:

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

C'est ce que je recherchais en recherchant ceci:

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

Enumeratorcomprend Enumerable. Depuis 2.1, a Enumerableégalement une méthode #to_h. C'est pourquoi, on peut écrire: -

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

Parce que #each_slicesans bloc nous donne Enumerator, et selon l'explication ci-dessus, nous pouvons appeler la #to_hméthode sur l' Enumeratorobjet.

Vous pouvez essayer comme ça, pour un seul tableau

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

pour tableau de tableau

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

ou, si vous détestez Hash[ ... ]:

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

ou, si vous êtes un fan paresseux de la programmation fonctionnelle cassée:

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"

Toutes les réponses supposent que le tableau de départ est unique. OP n'a pas spécifié comment gérer les tableaux avec des entrées en double, ce qui entraîne des clés en double.

Regardons:

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

Vous perdrez la item 1 => item 2paire car elle est remplacée par item 1 => item 5:

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

Toutes les méthodes, y compris le reduce(&:merge!)résultat de la même suppression.

Il se peut cependant que ce soit exactement ce à quoi vous vous attendez. Mais dans d'autres cas, vous souhaitez probablement obtenir un résultat avec une Arrayvaleur pour à la place:

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

La manière naïve serait de créer une variable d'assistance, un hachage qui a une valeur par défaut, puis de le remplir dans une boucle:

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

Il pourrait être possible d'utiliser assoc et reducede faire ci-dessus en une seule ligne, mais cela devient beaucoup plus difficile à raisonner et à lire.