Bagaimana cara mendapatkan output spesifik dengan menggunakan hash di Ruby?

Saya ingin mendapatkan hasil spesifik dengan mengulangi Ruby Hash.

Ini Hash yang ingin saya ulangi:

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

Ini adalah output yang ingin saya dapatkan:

1-----

a

b

2-----

c

3-----

d 

e

f

g

4-----

h

Di Ruby, bagaimana saya bisa mendapatkan hasil seperti itu dengan Hash saya?

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

Mengenai pesanan saya harus menambahkan, bahwa dalam 1,8 item akan diulang dalam urutan acak (well, sebenarnya dalam urutan yang didefinisikan oleh fungsi hashing Fixnum), sedangkan pada 1.9 akan diulang dalam urutan literal.

Cara paling dasar untuk beralih pada hash adalah sebagai berikut:

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

Memanggil semacam pada hash mengubahnya menjadi array bersarang dan kemudian mengurutkannya dengan kunci, jadi yang Anda butuhkan adalah ini:

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

Dan jika Anda tidak benar-benar membutuhkan bagian "----", itu bisa saja:

puts h.sort

Solusi satu baris saya:

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

Saya pikir ini cukup mudah dibaca.

Anda juga dapat memperbaiki Hash::each sehingga akan mendukung pencacahan rekursif . Ini adalah versi saya Hash::each( Hash::each_pair) dengan dukungan blok dan enumerator :

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

Berikut adalah penggunaan contoh dari Hash::eachdengan dan tanpa recursivebendera:

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

Ini adalah contoh dari pertanyaan itu sendiri:

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

Lihat juga versi rekursif saya Hash::merge( Hash::merge!) di sini .