Tableau de Hachage Ruby

Bon alors voici l'affaire, j'ai cherché sur google pour les âges à trouver une solution à ce et tandis qu'il ya beaucoup là-bas, ils ne semblent pas faire le travail, je suis à la recherche d'.

Fondamentalement, j'ai un tableau structuré comme ceci 

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

Je veux convertir cette Hachage de sorte qu'il ressemble à ceci 

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

c'est à dire les articles qui sont sur le 'même' index sont les clés et les éléments sur la "étrange" indices sont les valeurs.

Aucune idées de comment faire cela proprement? Je suppose que la force brutale méthode serait de simplement sortir tous le même index dans un tableau séparé et ensuite une boucle autour d'eux pour ajouter les valeurs.

InformationsquelleAutor djhworld | 2010-10-26
  1. 346
    a = ["item 1", "item 2", "item 3", "item 4"]
h = Hash[*a] # => { "item 1" => "item 2", "item 3" => "item 4" }

    Que c'est. Le * est appelé le splat opérateur.

    Une mise en garde par @Mike Lewis (dans les commentaires): "il faut Être très prudent avec cela. Ruby se développe splats sur la pile. Si vous faites cela avec un grand jeu de données, attendez-vous à sauter hors de votre pile de jetons."

    Si, pour la plupart générale des cas d'utilisation de cette méthode est grand, mais l'utilisation d'une autre méthode si vous voulez faire la conversion en lots de données. Par exemple, @Łukasz Niemier (également dans les commentaires) propose cette méthode de grands ensembles de données:

    h = Hash[a.each_slice(2).to_a]
    • ce qui ne l' * faire dans cet exemple?
    • le * est appelé le splat de l'opérateur. Il prend un tableau et la convertit en un littéral liste d'éléments. Donc *[1,2,3,4] => 1, 2, 3, 4. Dans cet exemple, le ci-dessus est équivalent à Hash["item 1", "item 2", "item 3", "item 4"]. Et Hash a un [] méthode qui accepte une liste d'arguments (ce qui fait que même des indices clés et les indices de valeurs), mais Hash[] ne pas accepter un tableau, de sorte que nous splat le tableau à l'aide de *.
    • Une autre utilisation de splat est à utiliser dans le sens inverse, à définir des méthodes avec des inconnus certain nombre de paramètres. E. g def whatever *args. Vous pouvez passer d'une liste comme whatever(7, 1, 3, 4). Et comme ci-dessus, *args représente une liste et args représente un tableau. Puisque vous êtes de passage dans une liste, vous êtes réellement en passant dans le *args. Ainsi args est un tableau, et que vous vous retrouvez avec args == [7, 1, 3, 4]. De sorte que vous pouvez passer en ce que les paramètres que vous voulez dans la méthode puis il suffit d'utiliser args pour y accéder.
    • Être très prudent. Ruby se développe splats sur la pile. Si vous faites cela avec un grand jeu de données, attendez-vous à sauter hors de votre pile de jetons.
    • merci pour l'avertissement. J'ai ajouté qu'à ma réponse (avec mention de la source pour vous).
    • Un autre inconvénient, cette méthode lève une exception si vous passez dans un tableau avec un nombre impair d'éléments. ArgumentError: odd number of arguments for Hash
    • Sur de grands tableaux de données vous pouvez utiliser Hash[a.each_slice(2).to_a].
    • merci pour cela. J'ai édité que dans ma réponse (avec mention de la source pour vous)
    • Que signifie "souffler votre pile" signifie?
    • le pile utilise une petite zone de mémoire que le programme alloue et des réserves pour certaines opérations spécifiques. Plus généralement, il est utilisé pour garder une pile de méthodes qui ont été appelé jusqu'à présent. C'est l'origine du terme trace de la pile, et c'est aussi pourquoi une infinité de méthode récursive peut provoquer un stack overflow. La méthode dans cette réponse aussi utilise la pile, mais depuis que la pile est seulement une petite zone de la mémoire, si vous essayez cette méthode avec un grand tableau, il va se remplir de la pile et de provoquer une erreur (une erreur dans le même sens comme un débordement de la pile).
    • Maintenant, il est possible de faire a.each_slice(2).to_h (au moins dans YARV).
    • Simple exemple de code pour voir l'erreur lorsque vous essayez d'envoyer un grand nombre d'arguments à l'aide de splat: ruby-forum.com/topic/1210854
    • Je ne pense pas que cette réponse est correcte plus. Liés à la documentation, au début de la réponse dit que to_h fonctionne sur un tableau de tableaux. L'exécution de ["item 1", "item 2", "item 3", "item 4"].to_h résultats dans TypeError Exception: wrong element type String at 0 (expected array). [["item 1", "item 2"], ["item 3", "item 4"]].to_h fonctionne bien. Je pense que @hauleth est droit, la bonne réponse lors de mes tests avec Ruby 2.5.3 est a.each_slice(2).to_h
    • Yup, ne semble pas fonctionner. Retiré cette réponse. De gauche à mon de hachage d'origine splat réponse depuis, jamais cessé de travailler, et a été ma réponse originale à cette question de toute façon.
    • Aussi la each_slice(2).to_h méthode, je l'avais déjà répertoriées dans ma réponse.

    InformationsquelleAutor Ben Lee
  2. 95

    Ruby 2.1.0 introduit un to_h méthode sur le Tableau qui fait ce que vous avez besoin si votre tableau original se compose de tableaux de paires clé-valeur: 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}
    • Magnifique!!! Beaucoup mieux que certains autres solutions ici.
    • pour le pré 2.1.0 ruby versions, vous pouvez utiliser le Hash::[] méthode pour obtenir des résultats similaires, aussi longtemps que vous avez des paires d'un tableau imbriqué. si a =[[:foo :1], [bar, 2]] --- Hash[a] => {:foo=>1, :bar=>2}
    • en effet, merci. Vous êtes correct (en ignorant les quelques fautes: bar doit être un symbole, le symbole :2 doit être un entier. Donc, votre expression corrigée est a = [[:foo, 1], [:bar, 2]]).
    InformationsquelleAutor Jochem Schulenklopper
  3. 27

    Suffit d'utiliser Hash.[] avec les valeurs dans le tableau. Par exemple:

    arr = [1,2,3,4]
Hash[*arr] #=> gives {1 => 2, 3 => 4}
    • ce n' [*arr] signifie?
    • convertit arr dans une liste d'arguments, c'est l'appel de la [] méthode de Hachage avec le contenu de l'arr comme arguments.
    InformationsquelleAutor Chuck
  4. 25

    Ou si vous disposez d'un tableau de [key, value] tableaux, vous pouvez le faire:

    [[1, 2], [3, 4]].inject({}) do |r, s|
  r.merge!({s[0] => s[1]})
end # => { 1 => 2, 3 => 4 }
    • Vous répondez n'est pas liée à la question et dans votre cas, il est toujours beaucoup plus facile d'utiliser le même Hash[*arr]
    • Nope. Il serait de retour { [1, 2] => [3, 4] }. Et puisque la question du titre dit "Tableau de Hachage" et intégré dans le "Hachage de Tableau" la méthode n': { 1 => 2, 3 => 4}.to_a # => [[1, 2], [3, 4]], j'ai pensé plus d'une pourrait se terminer ici, en essayant d'obtenir l'inverse de l'intégré dans le "Hachage de Tableau" la méthode. En fait, je suis arrivé ici de toute façon.
    • Désolé, j'ai ajouté un disque de secours astérisque. Hash[arr] fera le travail pour vous.
    • Oh... je vois... désolé :/ Et merci.
    • À mon humble avis la meilleure solution: Hash[*tableau.aplatir(1)]
    • Yossi: Désolé pour la résurrection des morts, mais il y a un gros problème avec sa réponse, et qui est l'utilisation de #inject méthode. Avec #merge!, #each_with_object doit avoir été utilisé. Si #inject est exigé, #merge plutôt que #merge! doit avoir été utilisé.

    InformationsquelleAutor Erik Escobedo
  5. 10

    C'est ce que je cherchais lorsque vous tapez ceci:

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

    • Vous ne voulez pas utiliser merge, elle construit et se défausse d'une nouvelle table de hachage par itération de boucle et est très lent. Si vous avez un tableau de hachages essayer [{a:1},{b:2}].reduce({}, :merge!) plutôt - il fusionne le tout dans la même (nouveau) de hachage.
    • Merci, c'est ce que je voulais trop! 🙂
    • Vous pouvez également faire .reduce(&:merge!)
    • [{a: 1}, {b: 2}].reduce(&:merge!) évalue à {:a=>1, :b=>2}
    • Cela fonctionne car injecter de l'/réduire a une fonction où vous pouvez omettre l'argument, dans lequel cas, il utilise le premier argument de la matrice pour fonctionner sur que l'argument d'entrée, et le reste de la matrice que dans le tableau. Combinez cela avec le symbole-à-proc, et vous obtenez ce concis de la construction. En d'autres termes [{a: 1}, {b: 2}].reduce(&:merge!) est le même que [{a: 1}, {b: 2}].reduce { |m, x| m.merge(x) } qui est le même que [{b: 2}].reduce({a: 1}) { |m, x| m.merge(x) }.
    • deux bémols: (1) ce mute le premier élément du tableau en place. si vous ne voulez pas le faire, vous devez transmettre explicitement dans {}, ou de l'utilisation non-mutation merge qui a le même problème de performance tel que décrit ci-dessus; (2) le tableau d'entrée doit avoir au moins 1 élément, sinon vous obtiendrez nil en arrière au lieu d'un hachage vide

    InformationsquelleAutor Karl Glaser
  6. 8

    Énumérateur comprend Énumérable. Depuis 2.1, Enumerable possède également une méthode #to_h. C'est pourquoi, nous pouvons é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_slice sans bloc nous donne Enumerator, et que par l'explication ci-dessus, nous pouvons appeler la #to_h méthode sur la Enumerator objet.

    InformationsquelleAutor Arup Rakshit
  7. 6

    Vous pouvez essayer comme ça, pour le 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}
    InformationsquelleAutor Jenorish
  8. 5
    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 paresseux fan de fractures de la programmation fonctionnelle:

    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"
    • Si vous n'avez pas entièrement la haine Hash[ ... ] mais vous voulez l'utiliser comme un enchaînés méthode (comme vous pouvez le faire avec to_h) vous pouvez combiner Boris suggestions et à écrire: arr.each_slice( 2 ).map { |e| e }.tap { |a| break Hash[a] }
    • Pour rendre compte de la sémantique du code ci-dessus, plus clair: Cela permettra de créer de un "paresseux hash" h, qui est initialement vide, et tirez sur les éléments du tableau d'origine un cas de besoin. Alors seulement seront-ils en fait être stockés dans des h!
    InformationsquelleAutor Boris Stitnicky