Каков наилучший способ преобразовать массив в хэш в Ruby
Вопрос
В Ruby задается массив в одной из следующих форм...
[apple, 1, banana, 2]
[[apple, 1], [banana, 2]]
...каков наилучший способ преобразовать это в хэш в виде...
{apple => 1, banana => 2}
Решение
ПРИМЕЧАНИЕ . Краткое и эффективное решение см. в ответе Марка-Андре Лафортуна ниже. р>
Этот ответ изначально предлагался в качестве альтернативы подходам, использующим flatten, которые были наиболее высоко оценены во время написания. Я должен был уточнить, что я не собирался представлять этот пример как лучшую практику или эффективный подход. Оригинальный ответ следует.
<Ч>Предупреждение! Решения, использующие flatten , не сохранят ключи или значения массива!
Опираясь на популярный ответ @John Topley, давайте попробуем:
a3 = [ ['apple', 1], ['banana', 2], [['orange','seedless'], 3] ]
h3 = Hash[*a3.flatten]
Это выдает ошибку:
ArgumentError: odd number of arguments for Hash
from (irb):10:in `[]'
from (irb):10
Конструктор ожидал массив четной длины (например, ['k1', 'v1,' k2 ',' v2 ']). Хуже всего то, что другой массив, сглаженный до четной длины, просто тихо дал бы нам хэш с неправильными значениями.
Если вы хотите использовать ключи или значения массива, вы можете использовать map :
h3 = Hash[a3.map {|key, value| [key, value]}]
puts "h3: #{h3.inspect}"
Это сохраняет ключ массива:
h3: {["orange", "seedless"]=>3, "apple"=>1, "banana"=>2}
Другие советы
Просто используйте Hash [* array_variable.flatten]
Например:
a1 = ['apple', 1, 'banana', 2]
h1 = Hash[*a1.flatten(1)]
puts "h1: #{h1.inspect}"
a2 = [['apple', 1], ['banana', 2]]
h2 = Hash[*a2.flatten(1)]
puts "h2: #{h2.inspect}"
Использование Array # flatten (1)
ограничивает рекурсию, поэтому ключи и значения Array
работают так, как ожидается.
Лучший способ - использовать Массив # to_h код>
:
[ [:apple,1],[:banana,2] ].to_h #=> {apple: 1, banana: 2}
Обратите внимание, что to_h
также принимает блок:
[:apple, :banana].to_h { |fruit| [fruit, "I like #{fruit}s"] }
# => {apple: "I like apples", banana: "I like bananas"}
Примечание : to_h
принимает блок в Ruby 2.6.0+; для ранних рубинов вы можете использовать мой backports
и require 'backports / 2.6. 0 / перечислим / to_h код>
to_h
без блока был представлен в Ruby 2.1.0.
До Ruby 2.1 можно было использовать менее разборчивый Hash []
:
array = [ [:apple,1],[:banana,2] ]
Hash[ array ] #= > {:apple => 1, :banana => 2}
Наконец, будьте осторожны с любыми решениями, использующими flatten
, это может создать проблемы со значениями, которые являются самими массивами.
Обновить
Ruby 2.1.0 выпущен сегодня.И я иду с тобой Array#to_h
(примечания к выпуску и ruby-док), что решает проблему преобразования Array
к a Hash
.
Пример Ruby docs:
[[:foo, :bar], [1, 2]].to_h # => {:foo => :bar, 1 => 2}
Редактировать: увидев ответы, опубликованные в то время, когда я писал, Хэш [a.flatten], кажется, подходит. Должно быть, пропустил этот бит в документации, когда я обдумывал ответ. Думаю, что решения, которые я написал, могут быть использованы в качестве альтернативы, если это необходимо.
Вторая форма проще:
a = [[:apple, 1], [:banana, 2]]
h = a.inject({}) { |r, i| r[i.first] = i.last; r }
a = массив, h = хеш, r = хэш возвращаемого значения (тот, в котором мы накапливаем), i = элемент в массиве
Самый лучший способ, которым я могу представить первую форму, - это что-то вроде этого:
a = [:apple, 1, :banana, 2]
h = {}
a.each_slice(2) { |i| h[i.first] = i.last }
Вы также можете просто преобразовать 2D-массив в хеш, используя:
1.9.3p362 :005 > a= [[1,2],[3,4]]
=> [[1, 2], [3, 4]]
1.9.3p362 :006 > h = Hash[a]
=> {1=>2, 3=>4}
Добавление к ответу, но с использованием анонимных массивов и аннотирования:
Hash[*("a,b,c,d".split(',').zip([1,2,3,4]).flatten)]
Разбираем этот ответ на части, начиная изнутри:
"a,b,c,d"
на самом деле это строка.split
через запятую в массив.zip
это вместе со следующим массивом.[1,2,3,4]
является фактическим массивом.
Промежуточным результатом является:
[[a,1],[b,2],[c,3],[d,4]]
затем flatten преобразует это в:
["a",1,"b",2,"c",3,"d",4]
а потом:
*["a",1,"b",2,"c",3,"d",4]
разворачивает это в
"a",1,"b",2,"c",3,"d",4
которые мы можем использовать в качестве аргументов для Hash[]
способ:
Hash[*("a,b,c,d".split(',').zip([1,2,3,4]).flatten)]
что приводит к:
{"a"=>1, "b"=>2, "c"=>3, "d"=>4}
Краткое содержание & TL;DR:
Этот ответ, как мы надеемся, будет исчерпывающим обобщением информации из других ответов.
Очень короткая версия, учитывая данные из вопроса, плюс пара дополнительных:
flat_array = [ apple, 1, banana, 2 ] # count=4
nested_array = [ [apple, 1], [banana, 2] ] # count=2 of count=2 k,v arrays
incomplete_f = [ apple, 1, banana ] # count=3 - missing last value
incomplete_n = [ [apple, 1], [banana ] ] # count=2 of either k or k,v arrays
# there's one option for flat_array:
h1 = Hash[*flat_array] # => {apple=>1, banana=>2}
# two options for nested_array:
h2a = nested_array.to_h # since ruby 2.1.0 => {apple=>1, banana=>2}
h2b = Hash[nested_array] # => {apple=>1, banana=>2}
# ok if *only* the last value is missing:
h3 = Hash[incomplete_f.each_slice(2).to_a] # => {apple=>1, banana=>nil}
# always ok for k without v in nested array:
h4 = Hash[incomplete_n] # or .to_h => {apple=>1, banana=>nil}
# as one might expect:
h1 == h2a # => true
h1 == h2b # => true
h1 == h3 # => false
h3 == h4 # => true
Далее следует обсуждение и подробности.
Настройка:переменные
Чтобы показать данные, которые мы будем использовать заранее, я создам несколько переменных для представления различных возможностей для этих данных.Они подразделяются на следующие категории:
Основываясь на том, что было непосредственно в вопросе, поскольку a1
и a2
:
(Примечание:Я предполагаю , что apple
и banana
были предназначены для представления переменных.Как и другие, с этого момента я буду использовать строки, чтобы входные данные и результаты могли совпадать.)
a1 = [ 'apple', 1 , 'banana', 2 ] # flat input
a2 = [ ['apple', 1], ['banana', 2] ] # key/value paired input
Многозначные ключи и/или значения, как a3
:
В некоторых других ответах была представлена другая возможность (которую я подробно описываю здесь) – ключи и / или значения сами по себе могут быть массивами:
a3 = [ [ 'apple', 1 ],
[ 'banana', 2 ],
[ ['orange','seedless'], 3 ],
[ 'pear', [4, 5] ],
]
Несбалансированный массив, как a4
:
Для пущей убедительности я подумал, что добавлю один для случая, когда у нас могут быть неполные входные данные:
a4 = [ [ 'apple', 1],
[ 'banana', 2],
[ ['orange','seedless'], 3],
[ 'durian' ], # a spiky fruit pricks us: no value!
]
А теперь за работу:
Начиная с изначально плоского массива, a1
:
Некоторые предлагали использовать #to_h
(который появился в Ruby 2.1.0 и может быть перенесенный в прошлое к более ранним версиям).Для изначально плоского массива это не работает:
a1.to_h # => TypeError: wrong element type String at 0 (expected array)
Используя Hash::[]
в сочетании с оператор шлепка делает:
Hash[*a1] # => {"apple"=>1, "banana"=>2}
Итак, это решение для простого случая, представленного a1
.
С массивом массивов пар ключ /значение, a2
:
С массивом [key,value]
введите массивы, есть два пути для этого.
Первый, Hash::[]
все еще работает (как это было с *a1
):
Hash[a2] # => {"apple"=>1, "banana"=>2}
А потом еще #to_h
работает сейчас:
a2.to_h # => {"apple"=>1, "banana"=>2}
Итак, два простых ответа для простого случая вложенного массива.
Это остается верным даже для подмассивов в качестве ключей или значений, как с a3
:
Hash[a3] # => {"apple"=>1, "banana"=>2, ["orange", "seedless"]=>3, "pear"=>[4, 5]}
a3.to_h # => {"apple"=>1, "banana"=>2, ["orange", "seedless"]=>3, "pear"=>[4, 5]}
Но у дурианов есть шипы (аномальные структуры создают проблемы).:
Если мы получили несбалансированные входные данные, мы столкнемся с проблемами с #to_h
:
a4.to_h # => ArgumentError: wrong array length at 3 (expected 2, was 1)
Но Hash::[]
все еще работает, просто настройка nil
в качестве значения для durian
(и любой другой элемент массива в формате a4, который является просто массивом с 1 значением):
Hash[a4] # => {"apple"=>1, "banana"=>2, ["orange", "seedless"]=>3, "durian"=>nil}
Сглаживание - использование новых переменных a5
и a6
Упомянуто несколько других ответов flatten
, с или без 1
аргумент, итак, давайте создадим несколько новых переменных:
a5 = a4.flatten
# => ["apple", 1, "banana", 2, "orange", "seedless" , 3, "durian"]
a6 = a4.flatten(1)
# => ["apple", 1, "banana", 2, ["orange", "seedless"], 3, "durian"]
Я решил использовать a4
в качестве базовых данных из-за возникшей у нас проблемы с балансом, которая проявилась с a4.to_h
.Я думаю позвонить flatten
возможно, кто-то может использовать один из подходов, чтобы попытаться решить эту проблему, который может выглядеть следующим образом.
flatten
без аргументов (a5
):
Hash[*a5] # => {"apple"=>1, "banana"=>2, "orange"=>"seedless", 3=>"durian"}
# (This is the same as calling `Hash[*a4.flatten]`.)
На наивный взгляд, это, кажется, работает, но мы неправильно начали с апельсинов без косточек, что также привело к 3
a Клавиша и durian
a значение.
И это, как и в случае с a1
, просто не работает:
a5.to_h # => TypeError: wrong element type String at 0 (expected array)
Итак a4.flatten
это не полезно для нас, мы бы просто хотели использовать Hash[a4]
Тот Самый flatten(1)
кейс (a6
):
Но как насчет лишь частичного выравнивания?Стоит отметить, что призывая Hash::[]
используя splat
на частично сплющенном массиве (a6
) является нет то же самое, что звонить Hash[a4]
:
Hash[*a6] # => ArgumentError: odd number of arguments for Hash
Предварительно сплющенный массив, все еще вложенный (альтернативный способ получения a6
):
Но что, если бы именно так мы получили массив в первую очередь?(То есть, по сравнению с a1
, это были наши входные данные - только на этот раз некоторые данные могут быть массивами или другими объектами.) Мы видели, что Hash[*a6]
не работает, но что, если бы мы все еще хотели получить поведение, при котором последний элемент (важно!смотрите ниже) выступал в качестве ключа для nil
ценность?
В такой ситуации все еще есть способ сделать это, используя Enumerable#each_slice
чтобы вернуться к ключу / значению пары как элементы во внешнем массиве:
a7 = a6.each_slice(2).to_a
# => [["apple", 1], ["banana", 2], [["orange", "seedless"], 3], ["durian"]]
Обратите внимание, что в итоге мы получаем новый массив, который не является "идентичный" чтобы a4
, но имеет те же значения:
a4.equal?(a7) # => false
a4 == a7 # => true
И, таким образом, мы снова можем использовать Hash::[]
:
Hash[a7] # => {"apple"=>1, "banana"=>2, ["orange", "seedless"]=>3, "durian"=>nil}
# or Hash[a6.each_slice(2).to_a]
Но есть проблема!
Важно отметить, что each_slice(2)
решение возвращает вещи к здравому смыслу только в том случае, если Последние ключом был тот, в котором отсутствовало значение.Если позже мы добавим дополнительную пару ключ / значение:
a4_plus = a4.dup # just to have a new-but-related variable name
a4_plus.push(['lychee', 4])
# => [["apple", 1],
# ["banana", 2],
# [["orange", "seedless"], 3], # multi-value key
# ["durian"], # missing value
# ["lychee", 4]] # new well-formed item
a6_plus = a4_plus.flatten(1)
# => ["apple", 1, "banana", 2, ["orange", "seedless"], 3, "durian", "lychee", 4]
a7_plus = a6_plus.each_slice(2).to_a
# => [["apple", 1],
# ["banana", 2],
# [["orange", "seedless"], 3], # so far so good
# ["durian", "lychee"], # oops! key became value!
# [4]] # and we still have a key without a value
a4_plus == a7_plus # => false, unlike a4 == a7
И два хэша, которые мы получим в результате этого, существенно отличаются друг от друга:
ap Hash[a4_plus] # prints:
{
"apple" => 1,
"banana" => 2,
[ "orange", "seedless" ] => 3,
"durian" => nil, # correct
"lychee" => 4 # correct
}
ap Hash[a7_plus] # prints:
{
"apple" => 1,
"banana" => 2,
[ "orange", "seedless" ] => 3,
"durian" => "lychee", # incorrect
4 => nil # incorrect
}
(Примечание:Я использую awesome_print
's ap
просто для того, чтобы было проще показать структуру здесь;для этого нет никаких концептуальных требований.)
Таким образом, each_slice
решение проблемы несбалансированного плоского ввода работает только в том случае, если несбалансированный бит находится в самом конце.
Блюда на вынос:
- Всякий раз, когда это возможно, настраивайте входные данные для этих объектов следующим образом
[key, value]
пары (вложенный массив для каждого элемента во внешнем массиве). - Когда вы действительно можете это сделать, либо
#to_h
илиHash::[]
сработает и то, и другое. - Если вы не в состоянии,
Hash::[]
в сочетании со шлепком (*
) будет работать, до тех пор, пока входные данные сбалансированы. - С помощью неуравновешенный и плоский массив в качестве входных данных, единственный способ, которым это будет работать вообще разумно, - это если Последние
value
предмет - единственный, которого не хватает.
Побочное примечание:Я публикую этот ответ, потому что чувствую, что есть ценность, которую нужно добавить – некоторые из существующих ответов содержат неверную информацию, и ни один (из тех, что я прочитал) не дал столь полного ответа, как я пытаюсь сделать здесь.Я надеюсь, что это полезно.Тем не менее я благодарю тех, кто был до меня, некоторые из которых вдохновили меня на некоторые части этого ответа.
если у вас есть массив, который выглядит следующим образом -
data = [["foo",1,2,3,4],["bar",1,2],["foobar",1,"*",3,5,:foo]]
и вы хотите, чтобы первые элементы каждого массива становились ключами для хэша, а остальные элементы становились массивами значений, тогда вы можете сделать что-то вроде этого -
data_hash = Hash[data.map { |key| [key.shift, key] }]
#=>{"foo"=>[1, 2, 3, 4], "bar"=>[1, 2], "foobar"=>[1, "*", 3, 5, :foo]}
Не уверен, что это лучший способ, но это работает:
a = ["apple", 1, "banana", 2]
m1 = {}
for x in (a.length / 2).times
m1[a[x*2]] = a[x*2 + 1]
end
b = [["apple", 1], ["banana", 2]]
m2 = {}
for x,y in b
m2[x] = y
end
Если числовые значения являются индексами seq, то у нас могут быть более простые способы ... Вот мой код, Мой Ruby немного заржавел
input = ["cat", 1, "dog", 2, "wombat", 3]
hash = Hash.new
input.each_with_index {|item, index|
if (index%2 == 0) hash[item] = input[index+1]
}
hash #=> {"cat"=>1, "wombat"=>3, "dog"=>2}