Array a Hash Ruby

De acuerdo, así que aquí está el trato, he estado buscando en Google durante años para encontrar una solución a esto y, aunque hay muchos por ahí, no parecen hacer el trabajo que estoy buscando.

Básicamente tengo una matriz estructurada como esta

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

Quiero convertir esto en un hash para que se vea así

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

es decir, los elementos que están en los índices 'pares' son las claves y los elementos en los índices 'impares' son los valores.

¿Alguna idea de cómo hacer esto limpiamente? Supongo que un método de fuerza bruta sería extraer todos los índices pares en una matriz separada y luego recorrerlos para agregar los valores.

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

Eso es. El *se llama el operador splat .

Una advertencia por @Mike Lewis (en los comentarios): "Ten mucho cuidado con esto. Ruby expande los símbolos en la pila. Si haces esto con un gran conjunto de datos, espera volar tu pila".

Por lo tanto, para la mayoría de los casos de uso general, este método es excelente, pero utilice un método diferente si desea realizar la conversión en muchos datos. Por ejemplo, @ Łukasz Niemier (también en los comentarios) ofrece este método para grandes conjuntos de datos:

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

Ruby 2.1.0 introdujo un to_hmétodo en Array que hace lo que usted requiere si su matriz original consiste en matrices de pares clave-valor: 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}

Solo use Hash.[]con los valores en la matriz. Por ejemplo:

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

O si tiene una matriz de [key, value]matrices, puede hacer:

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

Esto es lo que estaba buscando cuando busqué en Google:

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

Enumeratorincluye Enumerable. Desde entonces 2.1, Enumerabletambién tiene un método #to_h. Por eso, podemos escribir:

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_slicesin bloque nos da Enumerator, y según la explicación anterior, podemos llamar al #to_hmétodo en el Enumeratorobjeto.

Podrías intentarlo así, para una sola matriz

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 la matriz de la 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 } ]

o, si odias Hash[ ... ]:

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

o, si eres un fanático perezoso de la programación funcional rota:

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 las respuestas suponen que la matriz inicial es única. OP no especificó cómo manejar matrices con entradas duplicadas, lo que resulta en claves duplicadas.

Miremos a:

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

Perderá el item 1 => item 2par ya que se anula bij item 1 => item 5:

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

Todos los métodos, incluido el reduce(&:merge!) resultado en la misma eliminación.

Sin embargo, podría ser que esto es exactamente lo que esperas. Pero en otros casos, es probable que desee obtener un resultado con un Arrayvalor for:

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

La forma ingenua sería crear una variable auxiliar, un hash que tenga un valor predeterminado y luego completarlo en un bucle:

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

Puede ser posible usar assocy reducehacer lo anterior en una línea, pero eso se vuelve mucho más difícil de razonar y leer.