Matriz para Hash Ruby

Ok, então aqui está o negócio, eu venho pesquisando há séculos para encontrar uma solução para isso e, embora existam muitos por aí, eles não parecem fazer o trabalho que estou procurando.

Basicamente, eu tenho uma matriz estruturada como esta

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

Eu quero converter isso em um Hash para que fique assim

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

ou seja, os itens que estão nos índices 'pares' são as chaves e os itens nos índices 'ímpares' são os valores.

Alguma idéia de como fazer isso de forma limpa? Suponho que um método de força bruta seria apenas extrair todos os índices pares em uma matriz separada e depois fazer um loop em torno deles para adicionar os valores.

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

É isso aí. O *é chamado de operador splat .

Uma ressalva por @Mike Lewis (nos comentários): "Tenha muito cuidado com isso. Ruby expande splats na pilha. Se você fizer isso com um grande conjunto de dados, espere explodir sua pilha".

Portanto, na maioria dos casos de uso geral, esse método é ótimo, mas use um método diferente se você quiser fazer a conversão em muitos dados. Por exemplo, @ Łukasz Niemier (também nos comentários) oferece este método para grandes conjuntos de dados:

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

O Ruby 2.1.0 introduziu um to_hmétodo em Array que faz o que você precisa se sua matriz original consistir em matrizes de pares de valores-chave: 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 usar Hash.[]com os valores na matriz. Por exemplo:

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

Ou, se você tiver uma matriz de [key, value]matrizes, poderá:

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

Isto é o que eu estava procurando ao pesquisar isso:

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

Enumeratorinclui Enumerable. Desde 2.1, Enumerabletambém tem um método #to_h. Por isso, podemos escrever:

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

Porque #each_slicesem o bloco nos dá Enumerator, e conforme a explicação acima, podemos chamar o #to_hmétodo no Enumeratorobjeto.

Você pode tentar assim, para matriz única

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

para matriz de matriz

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, se você odeia Hash[ ... ]:

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

ou, se você é um fã preguiçoso de programação funcional interrompida:

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"

Todas as respostas assumem que a matriz inicial é única. O OP não especificou como lidar com matrizes com entradas duplicadas, o que resulta em chaves duplicadas.

Vamos olhar para:

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

Você perderá o item 1 => item 2par, pois é substituído por item 1 => item 5:

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

Todos os métodos, incluindo o reduce(&:merge!)resultado na mesma remoção.

Pode ser que isso seja exatamente o que você espera, no entanto. Mas em outros casos, você provavelmente deseja obter um resultado com um Arrayvalor for:

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

A maneira ingênua seria criar uma variável auxiliar, um hash que tenha um valor padrão e preenchê-lo em um loop:

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

Pode ser possível usar assoce reducefazer acima em uma linha, mas isso se torna muito mais difícil de raciocinar e ler.