एकल हैश पर हैश की सरणी मैपिंग रेल

Question

मेरे पास हैश की एक सरणी है जैसे:

 [{"testPARAM1"=>"testVAL1"}, {"testPARAM2"=>"testVAL2"}]

और मैं इसे इस तरह सिंगल हैश पर मैप करने की कोशिश कर रहा हूँ:

{"testPARAM2"=>"testVAL2", "testPARAM1"=>"testVAL1"}

मैंने इसका उपयोग करके हासिल किया है

  par={}
  mitem["params"].each { |h| h.each {|k,v| par[k]=v} } 

लेकिन मैं सोच रहा था कि क्या यह एक और अधिक मुहावरेदार तरीके से करना संभव है (अधिमानतः एक स्थानीय चर का उपयोग किए बिना)।

मैं यह कैसे कर सकता हूँ?

Answer 1

आप जो चाहें बना सकते हैं Enumerable#reduceऔर Hash#mergeपूरा कर सकते हैं।

input = [{"testPARAM1"=>"testVAL1"}, {"testPARAM2"=>"testVAL2"}]
input.reduce({}, :merge)
  is {"testPARAM2"=>"testVAL2", "testPARAM1"=>"testVAL1"}

इसके प्रत्येक तत्व के बीच मेथड कॉल करने की तरह एक सरणी प्रकार को कम करना।

उदाहरण के लिए [1, 2, 3].reduce(0, :+), कहने 0 + 1 + 2 + 3और देने जैसा है 6।

हमारे मामले में हम कुछ समान करते हैं, लेकिन मर्ज फ़ंक्शन के साथ, जो दो हैश का विलय करता है।

[{:a => 1}, {:b => 2}, {:c => 3}].reduce({}, :merge)
  is {}.merge({:a => 1}.merge({:b => 2}.merge({:c => 3})))
  is {:a => 1, :b => 2, :c => 3}

Comments

धन्यवाद, यह एक महान जवाब है :) बहुत अच्छी तरह से समझाया!

— बार्ट प्लैटाक

input.reduce (और: मर्ज) पर्याप्त है।

— प्रात:

@redgetan क्या कोई अलग है input.reduce(:merge)?

— डेविड वैन जाइस्ट

@ डेविड वैन गीस्ट: इस मामले में वे समकक्ष हैं। जैसा कि यहाँ इस्तेमाल किया गया अप्रमाणिक प्रतीक के बाहर एक ब्लॉक बनाता है। हालांकि, कम करने का एक विशेष मामला है जो एक प्रतीक को स्वीकार करता है। मैं उदाहरण को सरल बनाने के लिए एकरी एम्परसैंड ऑपरेटर से बचना चाहता था, लेकिन फिर भी यह सही है कि इस मामले में प्रारंभिक मूल्य वैकल्पिक है।

— cjhveal

ध्यान दें कि यदि आप merge!इसके बजाय उपयोग करते हैं mergeतो पहले हैश (जो आप नहीं चाहते हैं) को संशोधित करेंगे लेकिन प्रत्येक नए मर्ज के लिए एक मध्यस्थ हैश नहीं बनाएंगे।

— फ्रॉग्ज

Answer 2

कैसा रहेगा:

h = [{"testPARAM1"=>"testVAL1"}, {"testPARAM2"=>"testVAL2"}]
r = h.inject(:merge)

Comments

यह योजना प्रभावी रूप से वही है जो जोशुआ ने उत्तर दिया था, लेकिन सभी हैश पर बार-बार #merge (एक प्रतीक के रूप में पारित किया गया नाम) लागू होता है (आइटम के बीच एक ऑपरेटर को इंजेक्ट करने के बारे में इंजेक्शन के रूप में सोचें)। # अंक का संदर्भ लें ।

— 1

एचपीजे (&: मर्ज) के रूप में हमें कैसे एम्परसैंड की आवश्यकता नहीं है?

— डोनेटो

क्योंकि इंजेक्ट विधि एक प्रतीक को एक पैरामीटर के रूप में स्वीकार करती है जिसे विधि नाम के रूप में भी व्याख्यायित किया जाता है। यह इंजेक्शन की सुविधा है।

— शिगेया

Answer 3

# इंजेक्शन का प्रयोग करें

hashes = [{"testPARAM1"=>"testVAL1"}, {"testPARAM2"=>"testVAL2"}]
merged = hashes.inject({}) { |aggregate, hash| aggregate.merge hash }
merged # => {"testPARAM1"=>"testVAL1", "testPARAM2"=>"testVAL2"}

Answer 4

यहां आप एन्यूमरेबल क्लास से इंजेक्शन या कम इस्तेमाल कर सकते हैं क्योंकि ये दोनों एक-दूसरे के उपनाम हैं इसलिए दोनों के लिए कोई प्रदर्शन लाभ नहीं है।

 sample = [{"testPARAM1"=>"testVAL1"}, {"testPARAM2"=>"testVAL2"}]

 result1 = sample.reduce(:merge)
 # {"testPARAM1"=>"testVAL1", "testPARAM2"=>"testVAL2"}

 result2 = sample.inject(:merge)
 # {"testPARAM1"=>"testVAL1", "testPARAM2"=>"testVAL2"}