Вопрос:

Каков наилучший способ конвертировать массив в хеш в Ruby

ruby arrays hashmap

105236 просмотра

11 ответа

1108 Репутация автора

В Ruby дан массив в одной из следующих форм ...

[apple, 1, banana, 2]
[[apple, 1], [banana, 2]]

... Каков наилучший способ преобразовать это в хеш в виде ...

{apple => 1, banana => 2}
Автор: Nathan Fritz Источник Размещён: 02.09.2008 01:53

Ответы (11)


143 плюса

85594 Репутация автора

Просто использовать 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ключи и значения работают как положено.

Автор: John Topley Размещён: 02.09.2008 02:14

9 плюса

8251 Репутация автора

Редактировать: видел ответы, опубликованные в то время как я писал, Хэш [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 }
Автор: Daemin Размещён: 02.09.2008 02:16

0 плюса

12178 Репутация автора

Не уверен, что это лучший способ, но это работает:

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
Автор: Anders Sandvig Размещён: 02.09.2008 02:16

-1 плюса

102857 Репутация автора

Если числовые значения являются индексами 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}
Автор: Gishu Размещён: 02.09.2008 02:20

3 плюса

31 Репутация автора

Добавление к ответу, но с использованием анонимных массивов и аннотирования:

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}
Автор: StevenJenkins Размещён: 16.06.2010 07:14

85 плюса

2542 Репутация автора

Решение

ПРИМЕЧАНИЕ : для краткого и эффективного решения, пожалуйста, смотрите ответ Marc-André Lafortune ниже.

Этот ответ первоначально предлагался в качестве альтернативы подходам, использующим 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 ']). Хуже всего то, что другой массив, сглаженный до равной длины, просто молча дал бы нам хэш с неправильными значениями.

Если вы хотите использовать Array ключи или значения, вы можете использовать map :

h3 = Hash[a3.map {|key, value| [key, value]}]
puts "h3: #{h3.inspect}"

Это сохраняет ключ массива:

h3: {["orange", "seedless"]=>3, "apple"=>1, "banana"=>2}
Автор: Stew Размещён: 05.03.2012 06:17

5 плюса

51 Репутация автора

Вы также можете просто преобразовать 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} 
Автор: Priyanka Размещён: 11.01.2013 01:54

19 плюса

401 Репутация автора

Обновить

Ruby 2.1.0 выпущен сегодня . И я пришел с Array#to_h( заметки о выпуске и ruby-doc ), который решает проблему преобразования Arrayв Hash.

Пример документации по Ruby:

[[:foo, :bar], [1, 2]].to_h    # => {:foo => :bar, 1 => 2}
Автор: JanDintel Размещён: 25.12.2013 10:22

68 плюса

63404 Репутация автора

Лучший способ - использовать Array#to_h:

[ [:apple,1],[:banana,2] ].to_h  #=> {apple: 1, banana: 2}

Обратите внимание, что to_hтакже принимает блок:

[:apple, :banana].to_h { |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/enumerable/to_h'

to_h без блока был введен в Ruby 2.1.0.

До Ruby 2.1 можно было использовать менее разборчиво Hash[]:

array = [ [:apple,1],[:banana,2] ]
Hash[ array ]  #= > {:apple => 1, :banana => 2}

Наконец, с осторожностью относитесь к любым используемым решениям flatten, это может создать проблемы со значениями, которые сами являются массивами.

Автор: Marc-André Lafortune Размещён: 29.12.2013 11:58

0 плюса

69 Репутация автора

если у вас есть массив, который выглядит так -

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]}
Автор: user3588841 Размещён: 12.03.2015 11:27

2 плюса

6174 Репутация автора

Резюме & 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::[]сочетании с оператором splat делает:

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на ключ и durianна значение .

И это, как и с 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решение для несбалансированного плоского входа работает, только если несбалансированный бит находится в самом конце.


Take-сувенирной продукции:

  1. Когда это возможно, настройте входные данные для этих вещей в виде [key, value]пар (подмассив для каждого элемента во внешнем массиве).
  2. Если вы действительно можете это сделать, то #to_hили Hash::[]оба будут работать.
  3. Если вы не можете, в Hash::[]сочетании с splat ( *) будет работать, пока входы сбалансированы .
  4. С несбалансированным и плоским массивом в качестве входных данных единственный способ, которым это будет работать вообще, - это если последний value элемент является единственным, который отсутствует.

Примечание: я публикую этот ответ, потому что я чувствую, что есть ценность, которую нужно добавить - некоторые из существующих ответов содержат неверную информацию, и ни один (который я прочитал) не дал такого полного ответа, как я пытаюсь сделать здесь. Я надеюсь, что это полезно. Тем не менее, я благодарю тех, кто был до меня, некоторые из которых вдохновляли части этого ответа.

Автор: lindes Размещён: 03.12.2017 01:47
32x32