Как получить конкретный вывод, повторяя хэш в Ruby?

219

Я хочу получить конкретный вывод, повторяющий Ruby Hash.

Это хеш, который я хочу повторить:

hash = {
  1 => ['a', 'b'], 
  2 => ['c'], 
  3 => ['d', 'e', 'f', 'g'], 
  4 => ['h']
}

Это вывод, который я хотел бы получить:

1-----

a

b

2-----

c

3-----

d 

e

f

g

4-----

h

В Ruby, как я могу получить такой вывод с моим Hash?

ГНС
источник
3
Если вы выполняете итерацию хеша и ожидаете, что он будет упорядочен, вам, вероятно, потребуется использовать другой тип коллекции
Аллен Райс
Могу ли я передать хэш-значения в качестве опции переключателя?
StS
Я передаю хэш как параметр радио-кнопки ... но для первого варианта я получаю переключатель, для других значений не получаю его.
StS
1
@Allen: Хэши упорядочены в Ruby 1.9. Rails также предоставляет OrderedHash (который он использует только экономно), если вы используете Ruby <1.9. См. Culann.com/2008/01/rails-goodies-activesupportorderedhash
Джеймс А. Розен

Ответы:

324
hash.each do |key, array|
  puts "#{key}-----"
  puts array
end

Что касается порядка, я должен добавить, что в 1.8 элементы будут повторяться в случайном порядке (ну, фактически, в порядке, определенном хеш-функцией Fixnum), в то время как в 1.9 это будет повторяться в порядке литерала.

sepp2k
источник
2
что если ключ нигде не используется? , мы должны поставить ?вместо ключа? пример: |?, array|это правильный синтаксис?
huzefa biyawarwala
1
@huzefabiyawarwala Нет, ?недопустимое имя переменной в Ruby. Вы можете использовать _, но вам не нужно .
sepp2k
2
@huzefabiyawarwala Да, вы можете написать|_, v|
sepp2k
1
что использовать массив имен переменных вместо v или значения?
jrhicks
1
@jrhicks Потому что у OP есть хэш, значения которого являются массивами.
Радон Росборо
86

Самый простой способ перебора хеша заключается в следующем:

hash.each do |key, value|
  puts key
  puts value
end
tomascharad
источник
Да, это имеет смысл. Почему в ответе @ sepp2k есть ключ # {}?
совершиландройдер
о, неважно Я видел , что это было для строки интерполяции
committedandroider
48
hash.keys.sort.each do |key|
  puts "#{key}-----"
  hash[key].each { |val| puts val }
end
Erik
источник
18

Вызов sort для хэша преобразует его во вложенные массивы, а затем сортирует их по ключу, поэтому все, что вам нужно, это:

puts h.sort.map {|k,v| ["#{k}----"] + v}

И если вам на самом деле не нужна часть "----", это может быть просто:

puts h.sort
Гленн Макдональд
источник
Ключами хеша являются числа, поэтому '[k + "----"]' вызывает ошибку TypeError (String не может быть принудительно введена в Fixnum). Вам нужен '[k.to_s + "----"]'
Гленн Джекман
Правда достаточно. У меня были письма в моей тестовой версии. Исправлено использование еще лучшего "# {k} ----".
Гленн Макдональд
10

Мое однострочное решение:

hash.each { |key, array| puts "#{key}-----", array }

Я думаю, что это довольно легко читать.

Эли Тейсседу
источник
1

Вы также можете уточнить, Hash::each чтобы он поддерживал рекурсивное перечисление. Вот моя версия Hash::each( Hash::each_pair) с поддержкой блоков и перечислителей :

module HashRecursive
    refine Hash do
        def each(recursive=false, &block)
            if recursive
                Enumerator.new do |yielder|
                    self.map do |key, value|
                        value.each(recursive=true).map{ |key_next, value_next| yielder << [[key, key_next].flatten, value_next] } if value.is_a?(Hash)
                        yielder << [[key], value]
                    end
                end.entries.each(&block)
            else
                super(&block)
            end
        end
        alias_method(:each_pair, :each)
    end
end

using HashRecursive

Вот использование примеров из Hash::eachи без recursiveфлага:

hash = {
    :a => {
        :b => {
            :c => 1,
            :d => [2, 3, 4]
        },
        :e => 5
    },
    :f => 6
}

p hash.each, hash.each {}, hash.each.size
# #<Enumerator: {:a=>{:b=>{:c=>1, :d=>[2, 3, 4]}, :e=>5}, :f=>6}:each>
# {:a=>{:b=>{:c=>1, :d=>[2, 3, 4]}, :e=>5}, :f=>6}
# 2

p hash.each(true), hash.each(true) {}, hash.each(true).size
# #<Enumerator: [[[:a, :b, :c], 1], [[:a, :b, :d], [2, 3, 4]], [[:a, :b], {:c=>1, :d=>[2, 3, 4]}], [[:a, :e], 5], [[:a], {:b=>{:c=>1, :d=>[2, 3, 4]}, :e=>5}], [[:f], 6]]:each>
# [[[:a, :b, :c], 1], [[:a, :b, :d], [2, 3, 4]], [[:a, :b], {:c=>1, :d=>[2, 3, 4]}], [[:a, :e], 5], [[:a], {:b=>{:c=>1, :d=>[2, 3, 4]}, :e=>5}], [[:f], 6]]
# 6

hash.each do |key, value|
    puts "#{key} => #{value}"
end
# a => {:b=>{:c=>1, :d=>[2, 3, 4]}, :e=>5}
# f => 6

hash.each(true) do |key, value|
    puts "#{key} => #{value}"
end
# [:a, :b, :c] => 1
# [:a, :b, :d] => [2, 3, 4]
# [:a, :b] => {:c=>1, :d=>[2, 3, 4]}
# [:a, :e] => 5
# [:a] => {:b=>{:c=>1, :d=>[2, 3, 4]}, :e=>5}
# [:f] => 6

hash.each_pair(recursive=true) do |key, value|
    puts "#{key} => #{value}" unless value.is_a?(Hash)
end
# [:a, :b, :c] => 1
# [:a, :b, :d] => [2, 3, 4]
# [:a, :e] => 5
# [:f] => 6

Вот пример из самого вопроса:

hash = {
    1   =>  ["a", "b"], 
    2   =>  ["c"], 
    3   =>  ["a", "d", "f", "g"], 
    4   =>  ["q"]
}

hash.each(recursive=false) do |key, value|
    puts "#{key} => #{value}"
end
# 1 => ["a", "b"]
# 2 => ["c"]
# 3 => ["a", "d", "f", "g"]
# 4 => ["q"]

Также взгляните на мою рекурсивную версию Hash::merge( Hash::merge!) здесь .

MOPO3OB
источник