Come eseguire iterazioni su un hash in Ruby?

Question

Ho un hash come questo:

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

Come posso iterare al fine di ottenere l'output simile a questo:

1----- 

a 

b 

2----- 

c 

3----- 

a 

d 

f 

g 

Answer 1

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

Per quanto riguarda la fine devo aggiungere, che in 1.8 gli articoli sarà iterato in ordine casuale (beh, in realtà in un ordine definito dalla funzione di hashing di Fixnum), mentre in 1.9 verrà iterato nell'ordine del letterale.

Answer 2

hash.keys.sort.each do |key| 
    puts "#{key}-----" 
    hash[key].each { |val| puts val } 
end 

Answer 3

Calling sorta su un hash converte in array nidificati e poi le ordina a chiave, quindi tutto ciò che serve è questo:

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

E se non lo fai in realtà bisogno della "- -" parte, può essere solo:

puts h.sort 

Answer 4

Il modo più semplice per iterare su un hash è la seguente:

hash.each do |key, value| 
    puts key 
    puts value 
end 

Answer 5

È inoltre possibile perfezionareHash::each in modo da supportare l'enumerazione ricorsiva. Ecco la mia versione di Hash::each (Hash::each_pair) con blocco e enumeratore supporto:

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 

Ecco utilizzo esempi di Hash::each con e senza recursive bandiera:

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 

Ecco esempio dalla domanda stessa:

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

Inoltre, dare un'occhiata alla mia versione ricorsiva di Hash::merge (Hash::merge!) here.