arrays रूबी 2.3 में मैं 'ऐरे#डिग' और 'हैश#डिग' का उपयोग कैसे करूं?




ruby hash (2)

रूबी 2.3 ने Array और Hash पर एक नई विधि पेश की जिसे dig कहा जाता है। नई रिलीज के बारे में ब्लॉग पोस्ट में मैंने जो उदाहरण देखे हैं वे संकुचित और संकलित हैं:

# Hash#dig
user = {
  user: {
    address: {
      street1: '123 Main street'
    }
  }
}

user.dig(:user, :address, :street1) # => '123 Main street'

# Array#dig
results = [[[1, 2, 3]]]
results.dig(0, 0, 0) # => 1

मैं ट्रिपल-नेस्टेड फ्लैट एरे का उपयोग नहीं कर रहा हूं। यह कैसे उपयोगी होगा इसका यथार्थवादी उदाहरण क्या है?

अद्यतन करें

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

नेस्टेड हैश में लापता तत्वों के लिए NoMethodError से कैसे बचें, बार-बार शून्य जांच के बिना?

रूबी स्टाइल: कैसे जांचें कि नेस्टेड हैश तत्व मौजूद है या नहीं


एक अज्ञात दस्तावेज़ मॉडल से पढ़ने वाले स्प्लट ऑपरेटर के साथ एक तरीका होगा।

some_json = JSON.parse( '{"people": {"me": 6, ... } ...}' )
# => "{"people" => {"me" => 6, ... }, ... }
a_bunch_of_args = response.data[:query]
# => ["people", "me"]
some_json.dig(*a_bunch_of_args)
# => 6

हमारे मामले में, nil संदर्भों के कारण NoMethodError s हमारे उत्पादन वातावरण में अब तक की सबसे आम त्रुटियों से हैं।

नया Hash#dig आपको नेस्टेड तत्वों तक पहुंचने पर nil जांच को छोड़ने की अनुमति देता है। चूंकि हैश का सबसे अच्छा उपयोग होता है जब डेटा की संरचना अज्ञात होती है, या अस्थिर होती है, जिसके लिए आधिकारिक समर्थन होता है, यह बहुत समझ में आता है।

आइए अपना उदाहरण लें। निम्नलिखित:

user.dig(:user, :address, :street1)

इसके बराबर नहीं है:

user[:user][:address][:street1]

ऐसे मामले में जहां user[:user] या user[:user][:address] nil , इसके परिणामस्वरूप रनटाइम त्रुटि होगी।

इसके बजाय, यह निम्नलिखित के बराबर है, जो वर्तमान मुहावरे है:

user[:user] && user[:user][:address] && user[:user][:address][:street1]

ध्यान दें कि Hash#dig में कहीं और बनाए गए प्रतीकों की एक सूची को पारित करना कितना छोटा है, जबकि इस तरह की सूची से बाद के निर्माण को फिर से बनाना बहुत आसान नहीं है। Hash#dig आपको nil संदर्भों के बारे में चिंता किए बिना आसानी से गतिशील पहुंच करने की अनुमति देता है।

स्पष्ट रूप से Hash#dig भी बहुत छोटा है।

ध्यान देने योग्य एक महत्वपूर्ण बात यह है कि यदि कोई भी कुंजी चालू हो जाती है तो Hash#dig स्वयं nil हो जाती है, जिससे लाइनों में एक ही चरण की त्रुटियों का एक ही वर्ग हो सकता है, इसलिए यह एक अच्छा विचार हो सकता है कि यह एक अच्छा विचार हो समझदार डिफ़ॉल्ट। (एक ऑब्जेक्ट प्रदान करने का यह तरीका जो हमेशा अपेक्षित तरीकों का जवाब देता है उसे नल ऑब्जेक्ट पैटर्न कहा जाता है।)

फिर, आपके उदाहरण में, एक खाली स्ट्रिंग या "एन / ए" जैसे कुछ, जो समझ में आता है:

user.dig(:user, :address, :street1) || ""




hash