रूबी में हैश पर कैसे पुनरावृत्ति करें?

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 

आदेश मैं जोड़ने चाहिए के बारे में, 1.8 मदों में है कि यादृच्छिक क्रम में पुनरावृत्त किया जाएगा (ठीक है, वास्तव में फिक्सनम के हैशिंग फ़ंक्शन द्वारा परिभाषित आदेश में), जबकि 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 के मेरे रिकर्सिव संस्करण पर भी नज़र डालें।