रूबी में एक हैश की पुनरावृति करने वाला एक विशिष्ट आउटपुट कैसे प्राप्त करें?

Question

मैं एक विशिष्ट आउटपुट प्राप्त करना चाहता हूं जो रूबी हैश को पुनरावृत्त करता है।

यह वह हैश है जिसे मैं अधिक से अधिक करना चाहता हूं:

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

रूबी में, मैं अपने हाश के साथ ऐसा आउटपुट कैसे प्राप्त कर सकता हूं?

Comments

यदि आप एक हैश की पुनरावृत्ति कर रहे हैं और यह आदेश दिए जाने की अपेक्षा कर रहे हैं, तो आपको संभवतः कुछ अन्य संग्रह प्रकारों का उपयोग करने की आवश्यकता है

— एलन चावल

क्या मैं रेडियो बटन विकल्प के रूप में हैश मान पारित कर सकता हूँ ??

— sts

हैश को रेडियो बटन विकल्प के रूप में पारित कर रहा हूं .. लेकिन पहले विकल्प के लिए रेडियो बटन मिल रहा है, अन्य मूल्यों के लिए इसे नहीं मिल रहा है।

— sts

@ सभी: रूबी 1.9 में हिग्स का आदेश दिया गया है। यदि आप रूबी <1.9 पर हैं, तो रेल एक आर्डरहैड भी प्रदान करता है (इसका उपयोग केवल संयम से करता है)। देखिए culann.com/2008/01/rails-goodies-activesupportorderedhash

— James A. Rosen

Answer 1

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

आदेश के बारे में मुझे कहना चाहिए कि 1.8 में आइटम को यादृच्छिक क्रम में (अच्छी तरह से, वास्तव में फिक्सनम के हैशिंग फ़ंक्शन द्वारा परिभाषित एक क्रम में) पुनरावृत्त किया जाएगा, जबकि 1.9 में यह शाब्दिक के क्रम में पुनरावृत्त होगा।

Comments

अगर कहीं भी कुंजी का उपयोग नहीं किया जाता है तो यहां क्या होगा? । क्या हमें ?चाबी के स्थान पर रखने की आवश्यकता है ? उदाहरण के लिए: |?, array|यह मान्य सिंटैक्स है?

— हुजैफा बियावरवाला

@huzefabiyawarwala नहीं, ?रूबी में एक वैध चर नाम नहीं है। आप उपयोग कर सकते हैं _, लेकिन आपको इसकी आवश्यकता नहीं है।

— sepp2k

@huzefabiyawarwala हाँ, आप लिख सकते हैं|_, v|

— sepp2k

v या मान के बजाय चर नाम सरणी का उपयोग क्या है?

— jrhicks 13

@jrhicks क्योंकि ओपी में एक हैश होता है जिसके मान सरणियाँ हैं।

— रैडॉन रोज़बोरो

Answer 2

एक हैश पर पुनरावृति करने का सबसे मूल तरीका इस प्रकार है:

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

Comments

हाँ यह समझ में आता है। कुंजी पर @ sepp2k का उत्तर # {} क्यों है?

— committedandroider

ओह कोई बात नहीं। मैंने देखा कि यह स्ट्रिंग इंटरपोलेशन के लिए था

— प्रतिबद्ध

Answer 3

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

Answer 4

हैश पर कॉलिंग सॉर्ट इसे नेस्टेड सरणियों में परिवर्तित करता है और फिर उन्हें कुंजी द्वारा सॉर्ट करता है, इसलिए आपको इसकी आवश्यकता है:

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

और अगर आपको वास्तव में "----" भाग की आवश्यकता नहीं है, तो यह सिर्फ हो सकता है:

puts h.sort

Comments

हैश कुंजियाँ संख्याएँ होती हैं, इसलिए '[k + "----"]' एक टाइपर्रर उठाता है (स्ट्रिंग को फ़िक्नम में ज़ब्त नहीं किया जा सकता)। आपको '[k.to_s + "----"] की आवश्यकता है

— ग्लेन जैकमैन

आधी हकीकत। मेरे परीक्षण संस्करण में मेरे पास पत्र थे। निश्चित, और भी बेहतर "# {k} ----" का उपयोग करते हुए।

— ग्लेन mcdonald

Answer 5

मेरा एक लाइन समाधान:

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

मुझे लगता है कि यह पढ़ना बहुत आसान है।

Answer 6

आप इसे परिशोधित भी कर सकते हैं 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::eachrecursive

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!) यहाँ ।