루비에서 해시를 반복하는 특정 출력을 얻는 방법은 무엇입니까?

루비에서 해시를 반복하는 특정 출력을 얻는 방법은 무엇입니까?

루비 해시를 반복하는 특정 출력을 받고 싶습니다.

반복하고 싶은 해시입니다.

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

루비에서, 내 해시로 어떻게 그런 출력을 얻을 수 있습니까?

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

제가 추가해야 할 순서와 관련하여, 1.8에서는 항목이 무작위 순서로 반복될 것입니다(글쎄요, 실제로는 픽스넘의 해싱 함수에 의해 정의된 순서대로). 1.9에서는 리터럴 순서대로 반복될 것입니다.

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

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

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

해시 정렬을 호출하면 중첩 배열로 변환된 다음 키별로 정렬되므로 필요한 것은 다음과 같습니다.

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

그리고 실제로 "----" 부분이 필요하지 않다면, 다음과 같습니다.

puts h.sort

나의 한 줄 솔루션:

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

저는 그것이 읽기에 꽤 쉽다고 생각합니다.

다듬을 수도 있습니다. 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!) 여기.

언급URL : https://stackoverflow.com/questions/1227571/how-to-get-a-specific-output-iterating-a-hash-in-ruby