Ruby Academy · पाठ

Lazy Enumerators

Lazy evaluation

पाठ 3, कुल 4 में से13 चरण

Lazy Enumerators, CoddyKit पर Ruby Academy का एक निःशुल्क पाठ है। यह 4 में से 3वाँ पाठ है। इस अध्ययन पथ के 3 तक कोई भी पाठ पूरा पढ़ना निःशुल्क है — इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ व्यावहारिक अभ्यास भी उपलब्ध कराता है। यह Ruby Academy सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। Ruby Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

विलंबित मूल्यांकन

सामान्यतः Enumerable की विधियाँ पूरे संग्रह को एक साथ संसाधित करती हैं। एक विलंबित एन्यूमेरेटर तत्वों को एक-एक करके और केवल आवश्यकता होने पर संसाधित करता है। इससे आप बहुत बड़े या अनंत अनुक्रमों के साथ काम कर सकते हैं।

result = (1..Float::INFINITY).lazy.map { |n| n * 2 }.first(5)
p result

तुरंत चलने वाली विधियों की समस्या

अनंत श्रेणी पर map को lazy के बिना कॉल करने पर काम कभी पूरा नहीं होगा, क्योंकि वह पहले पूरी परिणाम-सारणी बनाने का प्रयास करता है।

# Eager version would hang. Lazy completes instantly:
first_three = (1..Float::INFINITY).lazy.select(&:even?).first(3)
p first_three

विलंबित एन्यूमेरेटर बनाना

विलंबित संस्करण पाने के लिए किसी भी enumerable पर .lazy कॉल करें। इसके बाद श्रृंखलाबद्ध विधियाँ भी विलंबित हो जाती हैं।

lazy = (1..10).lazy
puts lazy.class

बलपूर्वक चलाने तक कुछ नहीं चलता

विलंबित श्रृंखलाएँ एक विधि-विवरण बनाती हैं, लेकिन उसे चलाती नहीं हैं। first, to_a या force जैसी अंतिम विधि काम शुरू करती है।

chain = (1..Float::INFINITY).lazy.map { |n| n * n }
puts "Nothing computed yet"
p chain.first(4)

परिणामों को साकार करना

force (उपनाम to_a) सीमित विलंबित श्रृंखला को एक सारणी में साकार करता है।

result = (1..20).lazy.select(&:odd?).first(5)
p result
all = (1..6).lazy.map { |n| n * 10 }.force
p all

विलंब के साथ श्रृंखलाबद्ध करना

कई विलंबित क्रियाएँ अलग-अलग पूरे चक्रों में चलने के बजाय प्रत्येक तत्व के लिए आपस में क्रमबद्ध होकर चलती हैं। अगला मान शुरू होने से पहले हर मान पूरी श्रृंखला से होकर गुजरता है।

result = (1..Float::INFINITY)
  .lazy
  .map { |n| n * n }
  .select { |n| n.even? }
  .first(4)
p result

take और take_while

विलंबित take और take_while शर्त पूरी होते ही मान लेना बंद कर देते हैं।

result = (1..Float::INFINITY).lazy.take_while { |n| n < 6 }.to_a
p result

अनंत अनुक्रम

विलंबित एन्यूमेरेटर जनरेटरों के साथ बहुत अच्छा काम करते हैं। अनंत धाराओं का मॉडल बनाने के लिए उन्हें Enumerator के साथ जोड़ें।

naturals = Enumerator.new do |y|
  n = 1
  loop { y << n; n += 1 }
end
p naturals.lazy.map { |x| x * 3 }.first(5)

स्मृति की दक्षता

विलंबित श्रृंखलाएँ पूरे मध्यवर्ती संग्रह को कभी साकार नहीं करतीं, इसलिए बड़े डेटा को फ़िल्टर करके कुछ परिणामों तक सीमित करने पर वे स्मृति बचाती हैं।

big = (1..1_000_000).lazy
first_match = big.select { |n| n % 7 == 0 && n % 11 == 0 }.first
puts first_match

विलंबित मूल्यांकन का उपयोग कब करें

विलंबित मूल्यांकन का उपयोग करें जब:

स्रोत अनंत या बहुत बड़ा हो।
आपको केवल कुछ परिणाम चाहिए हों।
आप बड़ी मध्यवर्ती सारणियों से बचना चाहते हों।

छोटे संग्रहों के लिए तुरंत चलने वाली विधियाँ अधिक सरल और पर्याप्त तेज़ होती हैं।

fizz = (1..Float::INFINITY).lazy.select { |n| n % 3 == 0 }.first(5)
p fizz

सब कुछ एक साथ

विलंबित एन्यूमेरेटर काम को टालते हैं:

.lazy किसी श्रृंखला को विलंबित बनाता है।
काम तभी चलता है जब कोई अंतिम विधि मान खींचती है।
अनंत या बहुत बड़े अनुक्रमों के लिए यह बिल्कुल उपयुक्त है।

squares = (1..Float::INFINITY).lazy.map { |n| n * n }
p squares.select(&:odd?).first(4)

त्वरित जाँच

विलंबित एन्यूमेरेटर की अपनी समझ जाँचें।

इंटरैक्टिव पाठ में इसका उत्तर दें

पुनरावलोकन

आपने विलंबित एन्यूमेरेटर सीखे:

.lazy गणना को टालता है।
अंतिम विधियाँ (first, to_a, force) काम शुरू करती हैं।
हर मान आवश्यकता पड़ने पर पूरी श्रृंखला से होकर गुजरता है।
ये अनंत या बड़े अनुक्रमों के लिए आदर्श हैं।

p (1..Float::INFINITY).lazy.select(&:even?).map { |n| n + 1 }.first(3)

शुरुआत निःशुल्क

एआई शिक्षक के साथ Ruby सीखें — निःशुल्क

अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।

पाठ्यक्रम: 29
पाठ: 109

निःशुल्क सीखना शुरू करें पूरा पाठ्यक्रम देखें

अक्सर पूछे जाने वाले प्रश्न

क्या “Lazy Enumerators” पाठ निःशुल्क है?

हाँ — Ruby Academy अध्ययन पथ के 3 तक कोई भी पाठ, जिसमें “Lazy Enumerators” भी शामिल है, यहाँ वेब पर पूरा पढ़ना निःशुल्क है। इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ इंटरैक्टिव अभ्यास भी उपलब्ध कराता है। Ruby Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

“Lazy Enumerators” में मैं क्या सीखूँगा?

Lazy evaluation आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ Ruby Academy का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।

क्या Ruby Academy शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?

पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर Ruby Academy शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 3वाँ पाठ है।

“Lazy Enumerators” पाठ पूरा करने में कितना समय लगता है?

CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।

क्या मैं इस Ruby Academy पाठ में कोड लिख और चला सकता हूँ?

हाँ। हर Ruby Academy पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।

इस पाठ्यक्रम के सभी पाठ

← Ruby Academy पर वापस जाएँ