Array to Hash Ruby

Итак, вот в чем дело, я много лет гуглял, чтобы найти решение этой проблемы, и хотя их там много, похоже, они не выполняют ту работу, которую я ищу.

В основном у меня есть массив, структурированный так

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

Я хочу преобразовать это в хэш, чтобы он выглядел так

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

то есть элементы в «четных» индексах являются ключами, а элементы в «нечетных» индексах являются значениями.

Есть идеи, как сделать это чисто? Я полагаю, что методом грубой силы было бы просто вытащить все четные индексы в отдельный массив, а затем зациклить их, чтобы добавить значения.

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

Вот и все. Это *называется оператором сплат .

Одно предостережение в отношении @Mike Lewis (в комментариях): «Будьте очень осторожны с этим. Ruby расширяет знаки в стеке. Если вы делаете это с большим набором данных, ожидайте, что ваш стек будет взорван».

Таким образом, для большинства общих случаев использования этот метод хорош, но используйте другой метод, если вы хотите выполнить преобразование для большого количества данных. Например, @ Łukasz Niemier (также в комментариях) предлагает этот метод для больших наборов данных:

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

В Ruby 2.1.0 появился to_hметод Array, который делает то, что вам нужно, если ваш исходный массив состоит из массивов пар ключ-значение: 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}

Просто используйте Hash.[]со значениями в массиве. Например:

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

Или, если у вас есть массив [key, value]массивов, вы можете сделать:

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

Вот что я искал, когда гуглял это:

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

Enumeratorвключает в себя Enumerable. Так как 2.1, Enumerableтакже есть метод #to_h. Вот почему мы можем написать:

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

Потому что #each_sliceбез блока дает нам Enumerator, и согласно приведенному выше объяснению, мы можем вызвать #to_hметод Enumeratorобъекта.

Вы можете попробовать так, для одного массива

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

для массива массива

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

или, если вы ненавидите Hash[ ... ]:

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

или, если вы ленивый поклонник неработающего функционального программирования:

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"

Все ответы предполагают, что начальный массив уникален. OP не указывал, как обрабатывать массивы с дублирующимися записями, что приводит к дублированию ключей.

Давайте посмотрим на:

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

Вы потеряете item 1 => item 2пару, поскольку она переопределена bij item 1 => item 5:

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

Все методы, включая reduce(&:merge!) результат в том же удалении.

Вполне возможно, что это именно то, что вы ожидаете. Но в других случаях вы, вероятно, захотите получить результат со Arrayзначением for:

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

Наивным способом было бы создать вспомогательную переменную, хэш, который имеет значение по умолчанию, и затем заполнить его в цикле:

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

Можно было бы использовать assocи reduceделать выше в одной строке, но это становится гораздо сложнее рассуждать и читать.