रेल

Question

में हैश सूची से नेस्टेड कुंजी को कैसे निकालें I अब हैश सूची की नेस्टेड हैश कुंजी को निकालने के लिए कुछ घंटों तक प्रयास कर रहा हूं। मैं कई समाधान गैर नेस्टेड hashs जो इस तरह दिखता है देखा:

sample_hash = {"key1" => "value1", "key2" => "value2"} 
    sample_hash.except("key1") 

इस में जो परिणाम:

{"key2"=>"value2"} 

लेकिन तब ऐसा नहीं करता है, तो मैं नेस्टेड कुंजी के साथ एक हैश पर विधि को छोड़कर इस्तेमाल करने की कोशिश काम नहीं करता यहाँ मेरी कोड: को छोड़कर() विधि बिना किसी परिवर्तन के nested_hash रिटर्न

nested_hash = {"key1"=>"value1", "key2"=>{ 
              "nested_key1"=>"nestedvalue1", 
              "nested_key2"=>"nestedvalue2" 
              } 
       } 

    nested_hash.except("nested_key2") 

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

Answer 1

क्या

के बारे में

Hash[nested_hash.map {|k,v| [k,(v.respond_to?(:except)?v.except("nested_key2"):v)] }] 

=> {"key1"=>"value1", "key2"=>{"nested_key1"=>"nestedvalue1"}} 

ओह।

Answer 2

my_hash = Hash[nested_hash.map {|k,v| {k=>v.is_a? Array ? v.except("nested_key2") : v}}.map {|key, value| [key, value]}] 

कोशिश लेकिन इस मंद लगता है, काश मैं इस पथ नीचे शुरू कर दिया कभी नहीं, मुझे यकीन है के लिए वहाँ एक आसान तरीका है तैयार हूँ!

Answer 3

स्वीकार्य समाधान परिदृश्य के लिए मान्य है, लेकिन यदि आप ऐसा कुछ ढूंढ रहे हैं जो मनमाने ढंग से नेस्टेड हैश टेबल के लिए ऐसा करेगा तो आपको एक पुनरावर्ती समाधान की आवश्यकता होगी। मुझे कहीं भी उपयुक्त समाधान नहीं मिला, इसलिए मैंने एक here लिखा।

एनोटेशन के साथ यहां पुन: निर्मित:

class Hash 
    def except_nested(key) 
    r = Marshal.load(Marshal.dump(self)) # deep copy the hashtable 
    r.except_nested!(key) 
    end 

    def except_nested!(key) 
    self.except!(key) 
    self.each do |_, v| # essentially dfs traversal calling except! 
     v.except_nested!(key) if v.is_a?(Hash) 
    end 
    end 
end 

Hash वर्ग में जोड़ने ताकि आप इसे उसी तरह आप को छोड़कर फोन/छोड़कर कॉल कर सकते हैं! कहीं और।

t = { a: '1', b: { c: '3', d: '4' } } 

r = t.except_nested(:c) 
# r => {:a=>"1", :b=>{:d=>"4"}} 
# t => {:a=>"1", :b=>{:c=>"3", :d=>"4"}} 

t.except_nested!(:c) 
# t => {:a=>"1", :b=>{:d=>"4"}}