Ruby에서 해시를 반복하는 방법은 무엇입니까?

Question

다음과 같은 해시가 있습니다.

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

어떻게 이런 식으로 출력을 얻을 수 있습니까?

1----- 

a 

b 

2----- 

c 

3----- 

a 

d 

f 

g 

Answer 1

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

, 그 (실제로는 Fixnum의 해시 함수에 의해 정의 된 순서대로) 무작위 순서로 반복 될 것이며, 1.9에서는 문자 순서대로 반복 될 것입니다. 해시의 종류를 호출

Answer 2

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

Answer 3

중첩 배열로 변환하고 그래서 당신이 필요로하는 모든이입니다 키를 정렬합니다

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

그리고 당신이하지 않으면 실제로 "필요 - - "부분은, 그것은 단지가 될 수 있습니다

puts h.sort 

Answer 4

해시를 반복하는 가장 기본적인 방법은 다음과 같습니다

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

Answer 5

Hash::each도 가능하므로 재귀 열거 형을 지원합니다. 여기

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 

이 사용 예와 recursive 플래그없이 Hash::each의 : 여기 블록 및 열거 지원 Hash::each (Hash::each_pair)의 내 버전이

여기

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!) here을 살펴보십시오.