रूबी में हैश के हिस्से में कैसे पुनरावृत्ति करें? - रूबी, हैश, इटरेटर

h = Hash.new
(1..100).each { |v| h.store(v * 2, v*v) }

चाबियों का उपयोग किए बिना हैश के दिए गए हिस्से पर पुनरावृति करने का सबसे अच्छा तरीका क्या है? उदाहरण के लिए, तत्व 10 से तत्व 20 तक? रूबी का उपयोग 1.9.3।

संपादित करें - डेव की टिप्पणी के जवाब में:
मूल रूप से मैं डेटा को कुंजियों के माध्यम से एक्सेस करना चाहता था (इसलिए हैश)। लेकिन मैं तत्व संख्या द्वारा पुनरावृति करना चाहता हूं। BTW, प्रत्येक तत्व एक हैश है।

तो, हैश की हैश या सरणी के ऐरे को डिजाइन करने का सबसे अच्छा तरीका क्या है जो तत्व संख्या द्वारा पुनरावृत्त किया जा सकता है या कुंजी के द्वारा एक्सेस किया जा सकता है? डेटा निम्नलिखित की तरह दिखता है। लापता तारीखें हैं।

6/23/2011 -> 5, 6, 8, 3, 6
6/26/2011 -> 6, 8, 4, 8, 5
6/27/2011 -> 8, 4, 3, 2, 7

उत्तर:

उत्तर № 1 के लिए 4

अगर मैं समझता हूं कि आप क्या पूछ रहे हैं, तो आप अपने हैश के एक हिस्से पर निम्नानुसार पुनरावृति कर सकते हैं। यह आपको 2000 वें मूल्यों के माध्यम से 1001 वां स्थान देता है:

h.keys[1000..1999].each do |key|
# Do something with h[key]
end

उत्तर № 2 के लिए 1

मुझे लगता है कि आप इसके लिए बेहतर ऐरे का उपयोग करते हैं (रूबी 1.9.3 में हैश का आदेश दिया गया है लेकिन पहुंच विधि कुंजी है)। इसलिए:

a = h.values
# or
a = h.to_a

उत्तर № 3 के लिए 1

इसे एक अरै में बदलें टुकड़ा यह:

h.to_a[10..20].each { |k, v| do_stuff }

ध्यान दें कि रूबी 1.9 से पहले, हैश में तत्वों के क्रम की गारंटी नहीं है, इसलिए यह आवश्यक रूप से काम नहीं करेगा जैसा कि आप उम्मीद करते हैं।

वैकल्पिक रूप से, आप उपयोग कर सकते हैं each_with_index और अवांछित तत्वों पर छोड़ें:

h.each_with_index do |(k, v), i|
next unless (10..20).include?(i)
# do stuff
end

उत्तर के लिए 1 № 4
h = Hash.new
(1..100).each { |v| h.store(v * 2, v*v) }

#for an array of arrays
h.drop(9).take(10) #plus an optional block
#if the slice must be a hash:
slice = Hash[h.drop(9).take(10)]

लेकिन अगर यह एक बार-बार होने वाला ऑपरेशन है, तो आप डेटाबेस का उपयोग करके बेहतर हो सकते हैं।


संबंधित सवाल
सबसे लोकप्रिय