रूबी नेक्स्ट को समझना और कीवर्ड्स को तोड़ना

कीवर्ड, जैसे अगला &ब्रेक रूबी प्रोग्रामिंग भाषा का हिस्सा हैं, इसलिए यदि आप रूबी की पूरी समझ चाहते हैं तो आपको यह जानना होगा कि वे कैसे काम करते हैं।

उनका उपयोग किस लिए किया जाता है?

खैर, रूबी में, हमारे पास सभी प्रकार के लूप हैं।

पसंद करें :

• जबकि
• तक
• प्रत्येक

लूप लिखते समय, हो सकता है कि आप किसी पुनरावृत्ति को छोड़ना चाहें, या लूप को जल्दी समाप्त करना चाहें।

वहीं next &break कीवर्ड आते हैं!

आइए जानें कि उनका उपयोग कैसे करें।

रूबी नेक्स्ट कीवर्ड (स्किप इटरेशन)

next कीवर्ड आपको एक पुनरावृत्ति को छोड़ने की अनुमति देता है।

उदाहरण :

मान लें कि आप तार गिन रहे हैं।

और किसी कारण से आप 4 के आकार वाले स्ट्रिंग्स की गणना नहीं करना चाहते हैं।

आप ऐसा कर सकते हैं :

strings = ["one", "two", "four", "five"]

strings.inject(0) do |sum, str|
  next if str.size == 4

  sum + str.size
end

# nil

यह कोड काम नहीं करेगा।

आपको शून्य मिलता है।

क्यों?

क्योंकि next रिटर्न nil डिफ़ॉल्ट रूप से, जैसे return calling को कॉल करना वापसी मूल्य के बिना।

जैसा कि आप जानते होंगे…

inject का उपयोग करना ब्लॉक द्वारा लौटाया गया अंतिम मान लेता है और जो अगले पुनरावृत्ति का पहला तर्क बन जाता है।

दूसरे शब्दों में, sum हो जाता है nil ।

समाधान?

next बदलें इसके लिए लाइन:

next sum if str.size == 4

यह next बनाता है sum का मान लौटाएं ।

यदि प्रदर्शन सर्वोच्च प्राथमिकता नहीं है (अक्सर ऐसा नहीं होता है), तो आप next का उपयोग करने से बचने के लिए सरणी को पूर्व-फ़िल्टर कर सकते हैं ।

या इससे भी बेहतर :

strings = ["one", "two", "four", "five"]

strings.inject(0) { |sum, str| str.size == 4 ? sum : sum + str.size }

# 6

यह एक टर्नरी ऑपरेटर है।

मुझे लगता है कि रूबी आपको next . का उपयोग करने से बचने के लिए पर्याप्त टूल देती है ।

उनका इस्तेमाल करें!

रूबी ब्रेक कीवर्ड (लूप से जल्दी बाहर निकलें)

break कीवर्ड next like जैसा है , लेकिन यह लूप को समाप्त करता है और केवल एक पुनरावृत्ति को छोड़ने के बजाय एक मान देता है।

इसका उपयोग लूप से जल्दी वापसी के लिए किया जा सकता है।

return का उपयोग क्यों न करें कीवर्ड? क्योंकि यह वर्तमान पद्धति से बाहर निकलेगा, न कि केवल लूप से।

या बिना शर्त लूप को समाप्त करने के लिए।

इसे पसंद करें :

count = 0

loop do
  break if count == 10

  puts count

  count += 1
end

यह 0 से 9 तक की संख्याओं की एक सूची प्रिंट करता है।

एक बेहतर विकल्प times . का उपयोग करना होगा विधि, upto मेथड, या रेंज प्लस प्रत्येक मेथड।

उदाहरण :

0.upto(9).each(&method(:puts))

यह &method(:puts) कॉल करने के लिए सिर्फ एक शॉर्टकट है puts प्रत्येक नंबर के लिए।

भ्रम से बचना:एक रूबी विधि के रूप में अगला

सिर्फ इसलिए कि कुछ कीवर्ड के रूप में मौजूद है, इसका मतलब यह नहीं है कि इसे एक विधि नाम के रूप में उपयोग नहीं किया जा सकता है।

रूबी में कुछ वर्ग next implement लागू करते हैं एक विधि के रूप में।

जैसे String और Integer ।

उदाहरण :

1.next
# 2

परिणाम आश्चर्यजनक नहीं है, है ना?

इसके बारे में कैसे :

"zz".next
# "aaa"

यह थोड़ा और दिलचस्प है!

यह कैसे काम करता है?

खैर, हर वर्ग next . के अपने संस्करण को लागू करता है , जिसमें अगले मान के लिए तर्क शामिल है।

पूर्णांक . के लिए , यह केवल +1 है ।

स्ट्रिंग्स . के लिए , यह अंतिम वर्ण को एक से बढ़ा देता है (अगला वर्णमाला में / +1 नंबरों के लिए), तो अगर कोई कैरीओवर है (9 -> 0 , z -> a ), यह बाईं ओर के अगले वर्ण को बढ़ा देगा।

सारांश

आपने next . के बारे में जान लिया है &break रूबी में कीवर्ड, वे पुनरावृत्तियों को छोड़ने या लूप को जल्दी रोकने में आपकी मदद कैसे करते हैं।

अब आपकी रूबी कौशल का अभ्यास करने की बारी है 🙂

पढ़ने के लिए धन्यवाद!