रूबी में << के साथ हैश के लिए कुंजी / मान जोड़ी में जोड़ें

Question

रूबी में, कोई मौजूदा सरणियों में मानों को जोड़ सकता है <<:

a = []
a << "foo"

लेकिन, क्या आप मौजूदा हैश में कुंजी / मूल्य जोड़े भी जोड़ सकते हैं?

h = {}
h << :key "bar"

मुझे पता है तुम कर सकते हो:

h[:key] = ""
h[:key] << "bar"

लेकिन मैं ऐसा नहीं चाहता।

धन्यवाद।

Comments

क्यों नहीं h[:key] = "bar"?

— हउलेथ

यह काम नहीं करता है:h[:key] << "bar"

— क्रिस नीलसन

Answer 1

नहीं है merge!।

h = {}
h.merge!(key: "bar")
# => {:key=>"bar"}

Comments

मुझे नहीं लगता merge!कि केवल एक नई कुंजी / मूल्य जोड़ी बनाने के रूप में योग्य है क्योंकि यह वास्तव में किसी अन्य उद्देश्य के लिए उपयोग किया जाता है।

— पेरिक्लियो

अच्छी बात। मुझे लगता है कि यह अन्य कारकों के आधार पर भी समाप्त हो सकता है जो ओपी ने पोस्ट नहीं किया था।

— माइकल ड्यूरेंट

आह, धन्यवाद। लगता है कि स्टोर विधि कुछ ऐसा ही करती है। यह ज्यादातर एक अकादमिक प्रश्न था जैसा कि मैंने देखा है << को सरणियों के लिए अपील करने के तरीके के रूप में संदर्भित किया गया था लेकिन यह देखना चाहता था कि क्या यह हैश के लिए काम करता है। एक बार फिर धन्यवाद।

— जकार्पियो

अंतर यह है: storeबस एक नई जोड़ी जोड़ता है, यह परवाह नहीं करता है यदि कुंजी पहले से मौजूद है। साथ merge!तथापि, डुप्लिकेट चाबी के साथ प्रविष्टियों अधिरोहित कर रहे हैं ताकि विधि थोड़ा सिर्फ जोड़े जोड़ने से अधिक करता है। यदि आप दोनों को बेंचमार्क करते हैं, तो आप storeतेज (तुच्छ लेकिन विशेष रूप से छोटे हैश पर) पाएंगे

— पेरिक्लिस

@jcarpio धन्यवाद। Hash#merge!रिसीवर हैश Array#<<लौटाता है, जैसे रिसीवर सरणी देता है। Hash#storeएक पूरी तरह से अलग बात है। इसके अलावा, key: "bar"तर्क की स्थिति में हैश सिंटैक्स शुगर के साथ , मैंने सोचा कि यह निकटतम था जिसे आप अपने अंकन में प्राप्त कर सकते हैं। मुझे पता था कि यह वही है जो आप चाहते थे।

— आरा

Answer 2

चूंकि हैश स्वाभाविक रूप से ऑर्डर नहीं किए गए हैं, इसलिए अप्लाई करने की धारणा नहीं है। हालांकि, रूबी हैश 1.9 इंसर्शन ऑर्डर बनाए रखता है। यहां नई कुंजी / मूल्य जोड़े जोड़ने के तरीके दिए गए हैं।

सबसे सरल उपाय है

h[:key] = "bar"

यदि आप एक विधि चाहते हैं, तो उपयोग करें store:

h.store(:key, "bar")

यदि आप वास्तव में, वास्तव में "फावड़ा" ऑपरेटर ( <<) का उपयोग करना चाहते हैं , तो यह वास्तव में हैश के मूल्य को एक सरणी के रूप में जोड़ रहा है, और आपको कुंजी निर्दिष्ट करनी होगी:

h[:key] << "bar"

उपरोक्त केवल तभी काम करता है जब कुंजी मौजूद होती है। एक नई कुंजी संलग्न करने के लिए, आपको एक डिफ़ॉल्ट मान के साथ हैश को इनिशियलाइज़ करना होगा, जिसे आप इस तरह कर सकते हैं:

h = Hash.new {|h, k| h[k] = ''}
h[:key] << "bar"

आप बंदर पैच हैश को एक फावड़ा ऑपरेटर को शामिल करने के लिए लुभा सकते हैं जो आपके द्वारा लिखे गए तरीके से काम करता है:

class Hash
  def <<(k,v)
    self.store(k,v)
  end
end

हालांकि, यह अन्य संदर्भों में फावड़ा ऑपरेटर के लिए लागू "सिंटैक्टिक शुगर" का वारिस नहीं करता है:

h << :key, "bar" #doesn't work
h.<< :key, "bar" #works

Comments

पूरी तरह से! योगदान और अंतर्दृष्टि के लिए धन्यवाद।

— 23

ध्यान दें, रूबी 1.9 के रूप में, हैशिंग का आदेश दिया जाता है।

— स्टील

रूबी 1.9+ सम्मिलन आदेश को बनाए रखता है, लेकिन डेटा संरचना के रूप में एक हैश में किसी भी प्रकार के निहित आदेश की अवधारणा नहीं है।

— मार्क

Answer 3

नहीं, मुझे नहीं लगता कि आप मुख्य / मूल्य जोड़े को जोड़ सकते हैं। केवल एक चीज है सबसे करीब है कि मैं का उपयोग कर रहा है पता है storeविधि:

h = {}
h.store("key", "value")

Answer 4

शायद आप हैश # मर्ज करना चाहते हैं?

1.9.3p194 :015 > h={}
 => {} 
1.9.3p194 :016 > h.merge(:key => 'bar')
 => {:key=>"bar"} 
1.9.3p194 :017 > 

यदि आप जगह उपयोग में सरणी बदलना चाहते हैं merge!

1.9.3p194 :016 > h.merge!(:key => 'bar')
 => {:key=>"bar"} 

Comments

मुझे नहीं लगता कि mergeयह एक अच्छा विचार है क्योंकि यह एक नई सरणी देता है; मौजूदा हैश में नई जोड़ी नहीं जोड़ना।

— पेरिक्लियो

कैसे के merge!बजाय (यानी मौजूदा सरणी के लिए) merge?

— माइकल ड्यूरेंट

merge!इस संदर्भ में तकनीकी रूप से काम करता है, लेकिन मुझे लगता है कि इसका उपयोग केवल एक नई जोड़ी को जोड़ने के बजाय दो हैश को मर्ज करने के लिए किया जाना चाहिए। इसके अलावा, यदि आप बेंचमार्क करते हैं merge!, तो यह धीमी है store;)

— पेरिक्लिस

Answer 5

जैसे वे होते हैं, merge!और मौजूदा हैश को कीनेम के आधार पर अलग तरह से storeव्यवहार करते हैं, और इसलिए यह आपकी प्राथमिकता को प्रभावित करेगा। सिंटैक्स के दृष्टिकोण से इसके अलावा,merge! की key: "value"वाक्य रचना बारीकी जावास्क्रिप्ट और अजगर के खिलाफ मेल खाता है। मुझे हमेशा कॉमा-से-कुंजी जोड़े को अलग करने से नफरत है।

hash = {}
hash.merge!(key: "value")
hash.merge!(:key => "value")
puts hash

{:key=>"value"}

hash = {}
hash.store(:key, "value")
hash.store("key", "value")
puts hash

{:key=>"value", "key"=>"value"}

फावड़ा ऑपरेटर को <<काम करने के लिए, मैं मार्क थॉमस के उत्तर का उपयोग करने की सलाह दूंगा।

Answer 6

मुझे एक समान काम करना था लेकिन मुझे एक ही कुंजी के साथ मूल्यों को जोड़ने की आवश्यकता थी। जब मैं मर्ज या अपडेट का उपयोग करता हूं तो मैं समान कुंजियों के साथ मानों को धक्का नहीं दे सकता। इसलिए मुझे हैश की सरणी का उपयोग करना पड़ा।

    my_hash_static = {:header =>{:company => 'xx', :usercode => 'xx', :password => 'xx',
                      :type=> 'n:n', :msgheader => from}, :body=>[]}
    my_hash_dynamic = {:mp=>{:msg=>message, :no=>phones} }        
    my_hash_full = my_hash_static[:body].push my_hash_dynamic