इटरेटर

कंप्यूटर प्रोग्रामिंग में, एक पुनरावर्तक एक वस्तु (कंप्यूटिंग) है जो एक प्रोग्रामर को एक कंटेनर (डेटा संरचना), विशेष रूप से सूची (सार डेटा प्रकार) को पार करने में सक्षम बनाता है।^[1]^[2]^[3] विभिन्न प्रकार के पुनरावर्तक अक्सर एक कंटेनर (अमूर्त डेटा प्रकार) के इंटरफ़ेस (ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग) के माध्यम से प्रदान किए जाते हैं। हालांकि किसी दिए गए पुनरावर्तक का इंटरफ़ेस और सिमेंटिक्स निश्चित हैं, इटरेटर अक्सर एक कंटेनर कार्यान्वयन के तहत संरचनाओं के संदर्भ में कार्यान्वित होते हैं और अक्सर कंटेनर के लिए कसकर युग्मन (कंप्यूटर प्रोग्रामिंग) होते हैं ताकि इटरेटर के परिचालन शब्दार्थ को सक्षम किया जा सके। एक पुनरावर्तक ट्रैवर्सल करता है और एक कंटेनर में डेटा तत्वों तक पहुंच भी देता है, लेकिन स्वयं पुनरावृत्ति नहीं करता है (यानी, उस अवधारणा के साथ या शब्दावली के तुच्छ उपयोग के साथ कुछ महत्वपूर्ण स्वतंत्रता के बिना नहीं)^{[citation needed]}.

एक पुनरावर्तक व्यवहारिक रूप से कर्सर (डेटाबेस) के समान होता है। Iterators 1974 में CLU (प्रोग्रामिंग लैंग्वेज) प्रोग्रामिंग लैंग्वेज के लिए डेट करते हैं।

विवरण

आंतरिक इटरेटर

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

digits = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

squared_digits = map(lambda x: x**2, digits)
# Iterating over this iterator would result in 0, 1, 4, 9, 16, ..., 81.

बाहरी पुनरावर्तक और पुनरावर्तक पैटर्न

एक बाहरी पुनरावर्तक को एक प्रकार के सूचक (कंप्यूटर प्रोग्रामिंग) के रूप में माना जा सकता है जिसमें दो प्राथमिक संचालन होते हैं: वस्तु संग्रह में एक विशेष तत्व को संदर्भित करना (तत्व पहुंच कहा जाता है), और खुद को संशोधित करना ताकि यह अगले तत्व को इंगित कर सके (तत्व ट्रैवर्सल कहा जाता है) ).^[4] एक पुनरावर्तक बनाने का एक तरीका भी होना चाहिए ताकि यह कुछ पहले तत्व को इंगित करे और साथ ही यह निर्धारित करने का कोई तरीका हो कि इटरेटर ने कंटेनर में सभी तत्वों को समाप्त कर दिया है। भाषा और इच्छित उपयोग के आधार पर, पुनरावर्तक अतिरिक्त संचालन भी प्रदान कर सकते हैं या विभिन्न व्यवहार प्रदर्शित कर सकते हैं।

पुनरावर्तक का प्राथमिक उद्देश्य उपयोगकर्ता को कंटेनर की आंतरिक संरचना से अलग करते समय उपयोगकर्ता को कंटेनर के प्रत्येक तत्व को संसाधित करने की अनुमति देना है।^[2]यह कंटेनर को किसी भी तरह से तत्वों को संग्रहीत करने की अनुमति देता है, जबकि उपयोगकर्ता को इसका इलाज करने की अनुमति देता है जैसे कि यह एक साधारण अनुक्रम या सूची हो। एक पुनरावर्तक वर्ग आमतौर पर संबंधित कंटेनर वर्ग के साथ कड़े समन्वय में बनाया जाता है। आमतौर पर, कंटेनर पुनरावृत्त बनाने के तरीके प्रदान करता है।

लूप काउंटर को कभी-कभी लूप इटरेटर भी कहा जाता है। एक लूप काउंटर, हालांकि, केवल ट्रैवर्सल कार्यक्षमता प्रदान करता है न कि तत्व एक्सेस कार्यक्षमता।

जेनरेटर

पुनरावर्तकों को लागू करने का एक तरीका एक प्रतिबंधित रूप का उपयोग करना है, जिसे जनरेटर (कंप्यूटर विज्ञान) के रूप में जाना जाता है। एक सबरूटीन के विपरीत, एक जेनरेटर coroutine सिर्फ एक बार लौटने के बजाय अपने कॉलर को कई बार मान दे सकता है। अधिकांश पुनरावृत्त जनरेटर के रूप में स्वाभाविक रूप से अभिव्यक्त होते हैं, लेकिन क्योंकि जनरेटर अपने स्थानीय राज्य को मंगलाचरण के बीच संरक्षित करते हैं, वे विशेष रूप से जटिल, स्टेटफुल इटरेटर्स, जैसे ट्री ट्रैवर्सल के लिए उपयुक्त हैं। जनरेटर और पुनरावर्तक शब्दों के उपयोग में सूक्ष्म अंतर और भेद हैं, जो लेखकों और भाषाओं के बीच भिन्न होते हैं।^[5] पायथन (प्रोग्रामिंग लैंग्वेज) में, एक जनरेटर एक इटरेटर कंस्ट्रक्टर (ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग) है: एक फ़ंक्शन जो एक इटरेटर लौटाता है। पायथन जनरेटर का एक उदाहरण जो पायथन का उपयोग करके फाइबोनैचि संख्याओं के लिए पुनरावर्तक लौटाता है yield बयान इस प्रकार है:

def fibonacci(limit):
    a, b = 0, 1
    for _ in range(limit):
        yield a
        a, b = b, a + b

for number in fibonacci(100): # The generator constructs an iterator
    print(number)

अंतर्निहित इटरेटर्स

कुछ वस्तु-उन्मुख भाषाएँ जैसे C Sharp (प्रोग्रामिंग भाषा)|C#, C++ (बाद के संस्करण), वस्तु पास्कल (बाद के संस्करण), गो (प्रोग्रामिंग भाषा), जावा (प्रोग्रामिंग भाषा) (बाद के संस्करण), लुआ (प्रोग्रामिंग भाषा) , पर्ल, पायथन (प्रोग्रामिंग लैंग्वेज), रूबी (प्रोग्रामिंग भाषा) एक स्पष्ट इटरेटर ऑब्जेक्ट की शुरुआत के बिना कंटेनर ऑब्जेक्ट के तत्वों के माध्यम से पुनरावृति का एक आंतरिक कार्य तरीका प्रदान करते हैं। एक वास्तविक पुनरावर्तक वस्तु वास्तविकता में मौजूद हो सकती है, लेकिन यदि ऐसा होता है तो यह भाषा के स्रोत कोड के भीतर प्रकट नहीं होता है।^[4]^[6] निहित पुनरावृत्तियों को अक्सर foreach कथन (या समतुल्य) द्वारा प्रकट किया जाता है, जैसे कि निम्नलिखित पायथन उदाहरण में:

for value in iterable:
    print(value)

पायथन में, एक पुनरावृत्त एक वस्तु है जिसे एक पुनरावर्तक में परिवर्तित किया जा सकता है, जिसे बाद में लूप के दौरान पुनरावृत्त किया जाता है; यह निहित रूप से किया जाता है।

या दूसरी बार वे संग्रह वस्तु द्वारा ही बनाए जा सकते हैं, जैसा कि इस रूबी उदाहरण में है:

iterable.each do |value|
  puts value
end

इस पुनरावृत्ति शैली को कभी-कभी आंतरिक पुनरावृत्ति कहा जाता है क्योंकि इसका कोड पुनरावर्तनीय वस्तु (जो पुनरावृत्ति के सभी पहलुओं को नियंत्रित करता है) के संदर्भ में पूरी तरह से निष्पादित होता है, और प्रोग्रामर केवल प्रत्येक चरण पर निष्पादित करने के लिए ऑपरेशन प्रदान करता है (अज्ञात फ़ंक्शन का उपयोग करके)।

सूची की समझ या इसी तरह के निर्माणों का समर्थन करने वाली भाषाएं परिणाम सूची के निर्माण के दौरान पाइथन के रूप में अंतर्निहित पुनरावृत्तियों का उपयोग कर सकती हैं:

names = [person.name for person in roster if person.male]

कभी-कभी अंतर्निहित छिपी हुई प्रकृति केवल आंशिक होती है। सी ++ भाषा में अंतर्निहित पुनरावृत्ति के लिए कुछ फ़ंक्शन टेम्पलेट्स हैं, जैसे for_each(). इन कार्यों को अभी भी प्रारंभिक इनपुट के रूप में स्पष्ट इटरेटर ऑब्जेक्ट्स की आवश्यकता होती है, लेकिन बाद के पुनरावृत्ति उपयोगकर्ता को इटरेटर ऑब्जेक्ट का पर्दाफाश नहीं करते हैं।

स्ट्रीम

इटरेटर्स आगत प्रवाह का एक उपयोगी अमूर्त हैं - वे एक संभावित अनंत चलने योग्य (लेकिन जरूरी नहीं कि इंडेक्सेबल) ऑब्जेक्ट प्रदान करते हैं। कई भाषाएँ, जैसे कि पर्ल और पायथन, धाराओं को पुनरावृत्तियों के रूप में लागू करती हैं। पायथन में, इटरेटर डेटा की धाराओं का प्रतिनिधित्व करने वाली वस्तुएं हैं।^[7] धारा के वैकल्पिक कार्यान्वयन में डेटा-संचालित प्रोग्रामिंग|डेटा-चालित भाषाएँ, जैसे AWK और sed शामिल हैं।

इंडेक्सिंग के साथ तुलना

प्रक्रियात्मक भाषाओं में एक सरणी जैसे अनुक्रम में सभी तत्वों के माध्यम से सबस्क्रिप्ट ऑपरेटर और लूप काउंटर का उपयोग करना आम है। हालांकि इंडेक्सिंग का उपयोग कुछ वस्तु-उन्मुख कंटेनरों के साथ भी किया जा सकता है, पुनरावृत्तियों के उपयोग के कुछ फायदे हो सकते हैं:^[8]

काउंटिंग लूप सभी डेटा संरचनाओं के लिए उपयुक्त नहीं हैं, विशेष रूप से उन डेटा संरचनाओं के लिए जिनमें कोई या धीमी रैंडम एक्सेस नहीं है, जैसे सूची (कंप्यूटिंग) या ट्री डेटा संरचना।
Iterators सभी प्रकार की डेटा संरचनाओं पर पुनरावृति करने के लिए एक सुसंगत तरीका प्रदान कर सकते हैं, और इसलिए कोड को अधिक पठनीय, पुन: प्रयोज्य और डेटा संरचना में बदलाव के प्रति कम संवेदनशील बनाते हैं।
एक पुनरावर्तक पहुंच पर अतिरिक्त प्रतिबंध लागू कर सकता है, जैसे कि यह सुनिश्चित करना कि तत्वों को छोड़ा नहीं जा सकता है या पहले देखे गए तत्व को दूसरी बार एक्सेस नहीं किया जा सकता है।
एक इटरेटर कंटेनर ऑब्जेक्ट को इटरेटर को अमान्य किए बिना संशोधित करने की अनुमति दे सकता है। उदाहरण के लिए, एक बार एक पुनरावर्तक पहले तत्व से आगे बढ़ जाता है, तो अनुमानित परिणामों के साथ कंटेनर की शुरुआत में अतिरिक्त तत्व सम्मिलित करना संभव हो सकता है। इंडेक्सिंग के साथ यह समस्याग्रस्त है क्योंकि इंडेक्स नंबरों को बदलना होगा।

अपने तत्वों के माध्यम से पुनरावृति करते हुए एक कंटेनर की संशोधित करने की क्षमता आधुनिक वस्तु-उन्मुख प्रोग्रामिंग में आवश्यक हो गई है, जहां वस्तुओं और संचालन के प्रभावों के बीच अंतर्संबंध स्पष्ट नहीं हो सकते हैं। एक पुनरावर्तक का उपयोग करके इस प्रकार के परिणामों से अलग किया जाता है। हालाँकि, इस दावे को नमक के दाने के साथ लिया जाना चाहिए, क्योंकि अधिक बार नहीं, दक्षता कारणों से, इट्रेटर कार्यान्वयन कंटेनर से इतना कसकर बंधा होता है कि यह अंतर्निहित कंटेनर को स्वयं को अमान्य किए बिना संशोधन को रोकता है।

उन कंटेनरों के लिए जो स्मृति में अपने डेटा के चारों ओर घूम सकते हैं, कंटेनर के लिए, इटेटरेटर को अमान्य नहीं करने का एकमात्र तरीका है, किसी भी तरह से वर्तमान में जीवित इटरेटर्स का ट्रैक रखें और उन्हें फ्लाई पर अपडेट करें। चूंकि एक निश्चित समय में पुनरावर्तकों की संख्या बंधे हुए कंटेनर के आकार की तुलना में मनमाने ढंग से बड़ी हो सकती है, इसलिए उन सभी को अपडेट करने से कंटेनर के संचालन पर जटिलता की गारंटी बहुत कम हो जाएगी।

अपडेट की संख्या को कंटेनर आकार से अपेक्षाकृत सीमित रखने का एक वैकल्पिक तरीका एक प्रकार के हैंडल तंत्र का उपयोग करना होगा, जो कंटेनर के तत्वों के लिए अप्रत्यक्ष पॉइंटर्स का संग्रह है जिसे कंटेनर के साथ अपडेट किया जाना चाहिए, और इटरेटर्स को इंगित करने दें ये सीधे डेटा तत्वों के बजाय हैंडल करते हैं। लेकिन यह दृष्टिकोण इटरेटर प्रदर्शन को नकारात्मक रूप से प्रभावित करेगा, क्योंकि वास्तविक डेटा तत्व तक पहुंचने के लिए इसे डबल पॉइंटर को प्रभावित करना होगा। यह आमतौर पर वांछनीय नहीं है, क्योंकि पुनरावृत्तियों का उपयोग करने वाले कई एल्गोरिदम पुनरावृत्तियों के डेटा एक्सेस ऑपरेशन को अग्रिम विधि की तुलना में अधिक बार लागू करते हैं। इसलिए बहुत कुशल डेटा एक्सेस के साथ इटरेटर्स का होना विशेष रूप से महत्वपूर्ण है।

कुल मिलाकर, यह हमेशा सुरक्षा (इटरेटर हमेशा मान्य रहता है) और दक्षता के बीच एक समझौता है। अधिकांश समय, अतिरिक्त सुरक्षा इसके लिए भुगतान करने के लिए दक्षता मूल्य के लायक नहीं होती है। एक वैकल्पिक कंटेनर का उपयोग करना (उदाहरण के लिए एक वेक्टर के बजाय एक एकल लिंक्ड सूची) एक बेहतर विकल्प होगा (वैश्विक रूप से अधिक कुशल) यदि पुनरावृत्तियों की स्थिरता की आवश्यकता है।

पुनरावृत्तियों का वर्गीकरण

इटरेटर श्रेणियां

Iterators को उनकी कार्यक्षमता के अनुसार वर्गीकृत किया जा सकता है। यहाँ इटरेटर श्रेणियों की एक (गैर संपूर्ण) सूची है:^[9]^[10]

Category	Languages
Bidirectional iterator	C++
Forward iterator	C++
Input iterator	C++
Output iterator	C++
Random access iterator	C++
Trivial iterator	C++ (old STL)^[11]

इटरेटर प्रकार

इन भाषाओं के साथ उपयोग की जाने वाली विभिन्न भाषाएँ या पुस्तकालय इटरेटर प्रकार को परिभाषित करते हैं। उनमें से कुछ हैं^[12]

Type	Languages
Array iterator	PHP, R^[13]
Caching iterator	PHP
Constant iterator	C++,^[14] PHP
Directory iterator	PHP, Python
Filter iterator	PHP, R
Limit iterator	PHP
List iterator	Java,^[6] R
Recursive array iterator	PHP
XML iterator	PHP

विभिन्न प्रोग्रामिंग भाषाओं में

सी # और अन्य .NET भाषाएं

.NET फ्रेमवर्क में इटरेटर्स को एन्युमरेटर्स कहा जाता है और इसके द्वारा प्रतिनिधित्व किया जाता है IEnumerator इंटरफेस।^[15]^{: 189–190, 344}^[16]^: 53–54IEnumerator प्रदान करता है एक MoveNext() विधि, जो अगले तत्व के लिए आगे बढ़ती है और इंगित करती है कि क्या संग्रह का अंत हो गया है;^[15]^: 344^[16]^: 55–56^[17]^: 89 ए Current संपत्ति, वर्तमान में इंगित किए जा रहे तत्व का मूल्य प्राप्त करने के लिए।^[15]^: 344^[16]^: 56^[17]^: 89 और एक वैकल्पिक Reset() तरीका,^[15]^: 344 एन्युमरेटर को उसकी प्रारंभिक स्थिति में वापस लाने के लिए। एन्युमरेटर शुरू में पहले तत्व से पहले एक विशेष मान की ओर इशारा करता है, इसलिए एक कॉल to MoveNext() पुनरावृति प्रारंभ करने के लिए आवश्यक है।

एन्युमरेटर्स को आमतौर पर कॉल करके प्राप्त किया जाता है GetEnumerator() किसी वस्तु को लागू करने की विधि IEnumerable इंटरफेस।^[16]^: 54–56^[17]^: 54–56 ए Current संपत्ति, वर्तमान में इंगित किए जा रहे तत्व का मूल्य प्राप्त करने के लिए;^[15]^: 344^[16]^: 56^[17]^: 89कंटेनर वर्ग आमतौर पर इस इंटरफ़ेस को लागू करते हैं। हालाँकि, C Sharp (प्रोग्रामिंग लैंग्वेज) में foreach स्टेटमेंट | C# ऐसी विधि प्रदान करने वाली किसी भी वस्तु पर काम कर सकता है, भले ही वह लागू न हो IEnumerable (बतख टाइपिंग )।^[17]^: 89 दोनों इंटरफेस को .NET Framework#.NET Framework 2.0|.NET 2.0 में सामान्य प्रोग्रामिंग संस्करणों में विस्तारित किया गया था।

निम्नलिखित सी # 2.0 में इटरेटर्स का एक सरल उपयोग दिखाता है:

// explicit version
IEnumerator<MyType> iter = list.GetEnumerator();
while (iter.MoveNext())
    Console.WriteLine(iter.Current);

// implicit version
foreach (MyType value in list)
    Console.WriteLine(value);

C# 2.0 भी #Generators का समर्थन करता है: एक विधि जिसे रिटर्निंग के रूप में घोषित किया जाता है IEnumerator (या IEnumerable), लेकिन का उपयोग करता हैyield returnऑब्जेक्ट इंस्टेंस को वापस करने के बजाय तत्वों के अनुक्रम का उत्पादन करने के लिए कथन, संकलक द्वारा उचित इंटरफ़ेस को लागू करने वाली एक नई कक्षा में परिवर्तित किया जाएगा।

सी ++

C++ भाषा अपने C++ मानक पुस्तकालय में पुनरावृत्तियों का व्यापक उपयोग करती है और पुनरावृत्तियों की कई श्रेणियों का वर्णन करती है जो उनके द्वारा अनुमत संचालन के प्रदर्शनों की सूची में भिन्न होती हैं। बढ़ती संभावनाओं के क्रम में इनमें फॉरवर्ड इटरेटर्स, बिडायरेक्शनल इटरेटर्स और रैंडम एक्सेस इटरेटर्स शामिल हैं। सभी मानक कंटेनर टेम्प्लेट प्रकार इन श्रेणियों में से किसी एक के पुनरावर्तक प्रदान करते हैं। Iterators एक सरणी के तत्वों (जो वास्तव में पुनरावृत्तियों के रूप में उपयोग किया जा सकता है) के लिए पॉइंटर्स को सामान्यीकृत करते हैं, और उनके सिंटैक्स को C (प्रोग्रामिंग लैंग्वेज) पॉइंटर अंकगणित के समान बनाया गया है, जहां * और -> ऑपरेटरों का उपयोग उस तत्व को संदर्भित करने के लिए किया जाता है जिसमें इटरेटर पॉइंट और पॉइंटर अंकगणितीय ऑपरेटर पसंद करते हैं ++ एक कंटेनर के ट्रैवर्सल में पुनरावृत्तियों को संशोधित करने के लिए उपयोग किया जाता है।

पुनरावृत्तियों का उपयोग करने वाले ट्रैवर्सल में आमतौर पर एक अलग-अलग पुनरावर्तक शामिल होते हैं, और दो निश्चित पुनरावृत्त होते हैं जो एक सीमा को पार करने के लिए परिसीमन करते हैं। ऑपरेटर के अनुप्रयोगों की संख्या के संदर्भ में सीमित पुनरावृत्तियों के बीच की दूरी ++ निचली सीमा को ऊपरी सीमा में बदलने के लिए आवश्यक, निर्दिष्ट सीमा में वस्तुओं की संख्या के बराबर होती है; शामिल विशिष्ट पुनरावर्तक मानों की संख्या उससे एक अधिक है। अधिवेशन के अनुसार, निचला सीमित पुनरावर्तक सीमा में पहले तत्व की ओर इशारा करता है, जबकि ऊपरी सीमित पुनरावर्तक सीमा के किसी भी तत्व को इंगित नहीं करता है, बल्कि सीमा के अंत से परे होता है। पूरे कंटेनर के ट्रैवर्सल के लिए, begin() विधि निचली सीमा प्रदान करती है, और end() ऊपरी सीमा। उत्तरार्द्ध कंटेनर के किसी भी तत्व को बिल्कुल भी संदर्भित नहीं करता है, लेकिन एक वैध पुनरावर्तक मान है जिसकी तुलना की जा सकती है।

निम्न उदाहरण एक पुनरावर्तक का एक विशिष्ट उपयोग दिखाता है।

std::vector<int> items;
items.push_back(5); // Append integer value '5' to vector 'items'.
items.push_back(2); // Append integer value '2' to vector 'items'.
items.push_back(9); // Append integer value '9' to vector 'items'.

for (auto it = items.begin(); it != items.end(); ++it) { // Iterate through 'items'.
  std::cout << *it; // And print value of 'items' for current index.
}
// In C++11, the same can be done without using any iterators:
for (auto x : items) {
  std::cout << x; // Print value of each element 'x' of 'items'.
}

// Both of the for loops print "529".

Iterator प्रकार उन कंटेनर प्रकारों से अलग होते हैं जिनके साथ उनका उपयोग किया जाता है, हालांकि दोनों का उपयोग अक्सर संगीत कार्यक्रम में किया जाता है। पुनरावर्तक की श्रेणी (और इस प्रकार इसके लिए परिभाषित संचालन) आमतौर पर कंटेनर के प्रकार पर निर्भर करता है, उदाहरण के लिए सरणी या वैक्टर रैंडम एक्सेस इटरेटर प्रदान करते हैं, लेकिन सेट (जो कार्यान्वयन के रूप में एक लिंक्ड संरचना का उपयोग करते हैं) केवल बिडरेक्शनल इटरेटर प्रदान करते हैं। एक ही कंटेनर प्रकार में एक से अधिक संबंधित पुनरावर्तक प्रकार हो सकते हैं; उदाहरण के लिए std::vector<T> कंटेनर प्रकार ट्रैवर्सल की अनुमति देता है या तो (कच्चे) पॉइंटर्स का उपयोग इसके तत्वों के लिए करता है (प्रकार *<T>), या एक विशेष प्रकार के मान std::vector<T>::iterator, और फिर भी रिवर्स इटरेटर्स के लिए एक अन्य प्रकार प्रदान किया जाता है, जिनके संचालन को इस तरह से परिभाषित किया जाता है कि एक सामान्य (आगे) ट्रैवर्सल प्रदर्शन करने वाला एल्गोरिदम वास्तव में रिवर्स इटरेटर्स के साथ बुलाए जाने पर रिवर्स ऑर्डर में ट्रैवर्सल करेगा। अधिकांश कंटेनर एक अलग भी प्रदान करते हैं const_iterator किस प्रकार के संचालन के लिए इंगित मूल्यों को बदलने की अनुमति देने वाले कार्यों को जानबूझकर परिभाषित नहीं किया गया है।

एक कंटेनर वस्तु या उसके तत्वों की एक श्रृंखला का सरल ट्रैवर्सल (उन तत्वों के संशोधन सहित जब तक कि a const_iterator प्रयोग किया जाता है) अकेले इटरेटर का उपयोग करके किया जा सकता है। लेकिन कंटेनर प्रकार भी तरीके प्रदान कर सकते हैं insert या erase जो कंटेनर की संरचना को ही संशोधित करता है; ये कंटेनर क्लास के तरीके हैं, लेकिन इसके अलावा वांछित ऑपरेशन को निर्दिष्ट करने के लिए एक या अधिक पुनरावर्तक मानों की आवश्यकता होती है। हालांकि एक ही कंटेनर में एक साथ कई पुनरावर्तक इंगित करना संभव है, संरचना-संशोधित संचालन कुछ इटरेटर मानों को अमान्य कर सकता है (मानक प्रत्येक मामले के लिए निर्दिष्ट करता है कि यह ऐसा हो सकता है); अमान्य पुनरावर्तक का उपयोग करना एक त्रुटि है जो अपरिभाषित व्यवहार को जन्म देगी, और ऐसी त्रुटियों को रन टाइम सिस्टम द्वारा संकेतित करने की आवश्यकता नहीं है।

मानक फ़ंक्शन टेम्प्लेट के उपयोग के माध्यम से लागू पुनरावृत्ति भी C ++ द्वारा आंशिक रूप से समर्थित है, जैसे std::for_each(), std::copy() और std::accumulate().

जब उपयोग किया जाता है तो उन्हें मौजूदा इटरेटर्स के साथ प्रारंभ किया जाना चाहिए, आमतौर पर begin और end, जो उस सीमा को परिभाषित करता है जिस पर पुनरावृत्ति होती है। लेकिन पुनरावृति आगे बढ़ने के बाद कोई स्पष्ट पुनरावर्तक वस्तु सामने नहीं आती है। यह उदाहरण का उपयोग दिखाता है for_each.

ContainerType<ItemType> c; // Any standard container type of ItemType elements.

void ProcessItem(const ItemType& i) { // Function that will process each item of the collection.
  std::cout << i << std::endl;
}

std::for_each(c.begin(), c.end(), ProcessItem); // A for-each iteration loop.

प्रयोग करके ही प्राप्त किया जा सकता है std::copy, पासिंग ए std::ostream_iterator तीसरे पुनरावर्तक के रूप में मूल्य:

std::copy(c.begin(), c.end(), std::ostream_iterator<ItemType>(std::cout, "\n"));

चूँकि C++11, C++11#Lambda फ़ंक्शंस और एक्सप्रेशन सिंटैक्स का उपयोग ऑपरेशन को इनलाइन इनलाइन करने के लिए निर्दिष्ट करने के लिए किया जा सकता है, नामित फ़ंक्शन को परिभाषित करने की आवश्यकता से बचा जा सकता है। लैम्ब्डा फ़ंक्शन का उपयोग करके प्रत्येक पुनरावृत्ति का उदाहरण यहां दिया गया है:

ContainerType<ItemType> c; // Any standard container type of ItemType elements.

// A for-each iteration loop with a lambda function.
std::for_each(c.begin(), c.end(), [](const ItemType& i) { std::cout << i << std::endl; });

जावा

जावा (प्रोग्रामिंग भाषा) JDK 1.2 रिलीज़ में पेश किया गया, java.util.Iterator इंटरफ़ेस कंटेनर कक्षाओं की पुनरावृत्ति की अनुमति देता है। प्रत्येक Iterator प्रदान करता है एक next() और hasNext() तरीका,^[18]^{: 294–295} और वैकल्पिक रूप से a का समर्थन कर सकता है remove()^[18]^{: 262, 266} तरीका। Iterators संबंधित कंटेनर वर्ग द्वारा बनाए जाते हैं, आमतौर पर नामित विधि द्वारा iterator().^[19]^[18]^: 99^[18]^: 217 next() e> विधि पुनरावर्तक को आगे बढ़ाती है और पुनरावर्तक द्वारा इंगित मान लौटाती है। पहली कॉल पर पहला तत्व प्राप्त होता है next().^[18]^{: 294–295} यह निर्धारित करने के लिए कि कंटेनर में सभी तत्वों का दौरा कब किया गया है hasNext() परीक्षण विधि का प्रयोग किया जाता है।^[18]^: 262 निम्न उदाहरण पुनरावृत्तियों का एक सरल उपयोग दिखाता है:

Iterator iter = list.iterator();
// Iterator<MyType> iter = list.iterator(); // in J2SE 5.0
while (iter.hasNext()) {
    System.out.print(iter.next());
    if (iter.hasNext())
        System.out.print(", ");
}

उसे दिखाने के लिए hasNext() बार-बार कॉल किया जा सकता है, हम इसका उपयोग तत्वों के बीच अल्पविराम लगाने के लिए करते हैं लेकिन अंतिम तत्व के बाद नहीं।

यह दृष्टिकोण अग्रिम कार्रवाई को वास्तविक डेटा एक्सेस से ठीक से अलग नहीं करता है। यदि प्रत्येक अग्रिम के लिए डेटा तत्व का एक से अधिक बार उपयोग किया जाना चाहिए, तो इसे एक अस्थायी चर में संग्रहित करने की आवश्यकता है। जब डेटा एक्सेस के बिना अग्रिम की आवश्यकता होती है (अर्थात किसी दिए गए डेटा तत्व को छोड़ने के लिए), तब भी एक्सेस का प्रदर्शन किया जाता है, हालांकि इस मामले में लौटाए गए मान को अनदेखा कर दिया जाता है।

इसका समर्थन करने वाले संग्रह प्रकारों के लिए, remove() पुनरावर्तक की विधि कंटेनर से सबसे हाल ही में देखे गए तत्व को हटा देती है जबकि पुनरावर्तक को प्रयोग करने योग्य बनाए रखती है। कंटेनर के तरीकों को कॉल करके तत्वों को जोड़ना या हटाना (उसी धागा (कंप्यूटर विज्ञान) से भी) इटरेटर को अनुपयोगी बनाता है। अगला तत्व प्राप्त करने का प्रयास अपवाद फेंकता है। यदि कोई और तत्व शेष नहीं है तो एक अपवाद भी फेंका जाता है (hasNext() पहले झूठी वापसी की है)।

इसके अतिरिक्त, के लिए java.util.List वहां एक है java.util.ListIterator एक समान एपीआई के साथ लेकिन यह आगे और पीछे की पुनरावृत्ति की अनुमति देता है, सूची में इसकी वर्तमान अनुक्रमणिका प्रदान करता है और सूची तत्व को इसकी स्थिति में सेट करने की अनुमति देता है।

जावा प्लेटफार्म, जावा के मानक संस्करण 5.0 रिलीज ने पेश किया Iterable इंटरफ़ेस एक बढ़ाया समर्थन करने के लिए for (foreach) संग्रह और सरणियों पर पुनरावृति के लिए लूप। Iterable परिभाषित करता है iterator() विधि जो एक देता है Iterator.^[18]^: 266 एन्हांस्ड का उपयोग करना for पाश, पूर्ववर्ती उदाहरण के रूप में फिर से लिखा जा सकता है

for (MyType obj : list) {
    System.out.print(obj);
}

कुछ कंटेनर पुराने का भी उपयोग करते हैं (1.0 से) Enumeration कक्षा। यह प्रदान करता है hasMoreElements() और nextElement() तरीके लेकिन कंटेनर को संशोधित करने के लिए कोई तरीका नहीं है।

स्कैला

स्काला (प्रोग्रामिंग भाषा) में, पुनरावृत्तियों के पास संग्रह के समान तरीकों का एक समृद्ध सेट होता है, और इसका उपयोग सीधे लूप के लिए किया जा सकता है। दरअसल, पुनरावर्तक और संग्रह दोनों एक सामान्य आधार विशेषता से प्राप्त होते हैं - scala.collection.TraversableOnce. हालाँकि, स्काला संग्रह पुस्तकालय में उपलब्ध विधियों के समृद्ध सेट के कारण, जैसे map, collect, filter आदि, स्काला में प्रोग्रामिंग करते समय अक्सर पुनरावृत्तियों से सीधे निपटना आवश्यक नहीं होता है।

जावा पुनरावृत्तियों और संग्रहों को स्वचालित रूप से क्रमशः स्काला पुनरावृत्तियों और संग्रहों में परिवर्तित किया जा सकता है, केवल एक पंक्ति जोड़कर

import scala.collection.JavaConversions._

फ़ाइल के लिए। JavaConversions e> ऑब्जेक्ट ऐसा करने के लिए निहित रूपांतरण प्रदान करता है। अंतर्निहित रूपांतरण स्काला की एक विशेषता है: ऐसी विधियाँ, जो वर्तमान दायरे में दिखाई देने पर, उपयुक्त स्थान पर प्रासंगिक अभिव्यक्तियों में स्वचालित रूप से कॉल सम्मिलित करती हैं, जब वे अन्यथा नहीं होती हैं, तो उन्हें टाइपचेक करने के लिए।

MATLAB

MATLAB या तो देशी सरणियों या का उपयोग करके बाहरी और आंतरिक दोनों अंतर्निहित पुनरावृत्ति का समर्थन करता है cell सरणियाँ। बाहरी पुनरावृत्ति के मामले में जहां ट्रैवर्सल को आगे बढ़ाने और अगले तत्वों का अनुरोध करने के लिए उपयोगकर्ता पर है, कोई एक सरणी भंडारण संरचना के भीतर तत्वों के एक सेट को परिभाषित कर सकता है और तत्वों का उपयोग करके पार कर सकता है for-पाश निर्माण। उदाहरण के लिए,

% Define an array of integers
myArray = [1,3,5,7,11,13];

for n = myArray
   % ... do something with n
   disp(n)  % Echo integer to Command Window
end

का उपयोग करके पूर्णांकों की एक सरणी का पता लगाता है for कीवर्ड।

आंतरिक पुनरावृत्ति के मामले में जहां उपयोगकर्ता संग्रह के प्रत्येक तत्व पर प्रदर्शन करने के लिए पुनरावर्तक को एक ऑपरेशन की आपूर्ति कर सकता है, कई अंतर्निर्मित ऑपरेटरों और MATLAB फ़ंक्शंस को सरणी के प्रत्येक तत्व पर निष्पादित करने के लिए अधिभारित किया जाता है और संबंधित आउटपुट सरणी को अंतर्निहित रूप से लौटाता है . इसके अलावा, arrayfun और cellfun देशी सरणियों पर कस्टम या उपयोगकर्ता परिभाषित संचालन करने के लिए कार्यों का लाभ उठाया जा सकता है cell क्रमशः सरणियाँ। उदाहरण के लिए,

function simpleFun
% Define an array of integers
myArray = [1,3,5,7,11,13];

% Perform a custom operation over each element 
myNewArray = arrayfun(@(a)myCustomFun(a),myArray);

% Echo resulting array to Command Window
myNewArray

function outScalar = myCustomFun(inScalar)
% Simply multiply by 2
outScalar = 2*inScalar;

एक प्राथमिक कार्य को परिभाषित करता है simpleFun जो स्पष्ट रूप से कस्टम सबफंक्शन लागू करता है myCustomFun अंतर्निहित फ़ंक्शन का उपयोग करके किसी सरणी के प्रत्येक तत्व के लिए arrayfun.

वैकल्पिक रूप से, इटरेटर पैटर्न के कस्टम ऑब्जेक्ट उन्मुख MATLAB कार्यान्वयन को परिभाषित करके उपयोगकर्ता से सरणी भंडारण कंटेनर के तंत्र को अमूर्त करना वांछनीय हो सकता है। बाहरी पुनरावृत्ति का समर्थन करने वाला ऐसा कार्यान्वयन MATLAB सेंट्रल फ़ाइल एक्सचेंज आइटम डिज़ाइन पैटर्न: इटरेटर (व्यवहार) में प्रदर्शित किया गया है। यह MATLAB सॉफ़्टवेयर संस्करण 7.6 (R2008a) के साथ पेश किए गए नए वर्ग-परिभाषा सिंटैक्स में लिखा गया है और इसमें एक-आयामी विशेषता है cell तत्वों के एक विषम (डेटा प्रकार में) सेट को संग्रहीत करने के तंत्र के रूप में सूची (कंप्यूटिंग) (एडीटी) की सरणी प्राप्ति। यह स्पष्ट अग्रेषण सूची (कंप्यूटिंग) ट्रैवर्सल के साथ कार्यक्षमता प्रदान करता है hasNext(), next() और reset() ए में उपयोग के तरीके while-कुंडली।

पीएचपी

PHP का फोरच लूप |foreach लूप संस्करण 4.0 में पेश किया गया था और 4.0 बीटा 4 में मूल्यों के रूप में वस्तुओं के साथ संगत बनाया गया था।^[20] हालांकि, आंतरिक की शुरूआत के माध्यम से PHP 5 में पुनरावर्तकों के लिए समर्थन जोड़ा गया था^[21] Traversable इंटरफेस।^[22] PHP स्क्रिप्ट्स में कार्यान्वयन के लिए दो मुख्य इंटरफेस जो वस्तुओं को इसके माध्यम से पुनरावृत्त करने में सक्षम बनाते हैं foreach लूप हैं Iterator और IteratorAggregate. उत्तरार्द्ध को कार्यान्वयन वर्ग को सभी आवश्यक विधियों की घोषणा करने की आवश्यकता नहीं है, इसके बजाय यह एक म्यूटेटर विधि विधि () को लागू करता है।getIterator) जो का एक उदाहरण देता है Traversable. मानक PHP लाइब्रेरी विशेष पुनरावृत्तियों के साथ काम करने के लिए कई कक्षाएं प्रदान करती है।^[23] PHP 5.5 के बाद से जेनरेटर (कंप्यूटर प्रोग्रामिंग) का भी समर्थन करता है।^[24] सबसे सरल कार्यान्वयन एक सरणी लपेटकर है, यह PHP#TYPE-HINTING और सूचना छिपाने के लिए उपयोगी हो सकता है।

namespace Wikipedia\Iterator;

final class ArrayIterator extends \Iterator
{
    private array $array;

    public function __construct(array $array)
    {
        $this->array = $array;
    }

    public function rewind(): void
    {
        echo 'rewinding' , PHP_EOL;
        reset($this->array);
    }

    public function current()
    {
        $value = current($this->array);
        echo "current: {$value}", PHP_EOL;
        return $value;
    }

    public function key()
    {
        $key = key($this->array);
        echo "key: {$key}", PHP_EOL;
        return $key;
    }

    public function next()
    {
        $value = next($this->array);
        echo "next: {$value}", PHP_EOL;
        return $value;
    }

    public function valid(): bool
    {
        $valid = $this->current() !== false;
        echo 'valid: ', ($valid ? 'true' : 'false'), PHP_EOL;
        return $valid;
    }
}

उदाहरण वर्ग के सभी तरीकों का उपयोग पूर्ण फ़ोरैच लूप के निष्पादन के दौरान किया जाता है (foreach ($iterator as $key => $current) {}). पुनरावर्तक के तरीकों को निम्नलिखित क्रम में निष्पादित किया जाता है:

$iterator->rewind() यह सुनिश्चित करता है कि आंतरिक संरचना शुरुआत से शुरू होती है।
$iterator->valid() इस उदाहरण में सच हो जाता है।
$iterator->current() रिटर्न वैल्यू को स्टोर किया जाता है $value.
$iterator->key() रिटर्न वैल्यू को स्टोर किया जाता है $key.
$iterator->next() आंतरिक संरचना में अगले तत्व के लिए अग्रिम।
$iterator->valid() झूठा रिटर्न देता है और लूप निरस्त हो जाता है।

अगला उदाहरण एक PHP वर्ग दिखाता है जो लागू करता है Traversable इंटरफ़ेस, जिसे एक में लपेटा जा सकता है IteratorIterator वर्ग को डेटा पर लौटने से पहले उस पर कार्रवाई करने के लिए foreach कुंडली। साथ में उपयोग MYSQLI_USE_RESULT निरंतर PHP स्क्रिप्ट को बहुत कम स्मृति उपयोग के साथ अरबों पंक्तियों के परिणाम सेट को पुनरावृत्त करने की अनुमति देता है। ये सुविधाएँ न तो PHP के लिए और न ही इसके MySQL वर्ग के कार्यान्वयन के लिए अनन्य हैं (उदाहरण के लिए PDOStatement वर्ग लागू करता है Traversable इंटरफ़ेस भी)।

mysqli_report(MYSQLI_REPORT_ERROR | MYSQLI_REPORT_STRICT);
$mysqli = new \mysqli('host.example.com', 'username', 'password', 'database_name');

// The \mysqli_result class that is returned by the method call implements the internal Traversable interface.
foreach ($mysqli->query('SELECT `a`, `b`, `c` FROM `table`', MYSQLI_USE_RESULT) as $row) {
    // Act on the returned row, which is an associative array.
}

पायथन

पायथन (प्रोग्रामिंग लैंग्वेज) में इटरेटर्स भाषा का एक मूलभूत हिस्सा हैं और कई मामलों में अनदेखी हो जाती है क्योंकि वे इसमें अंतर्निहित रूप से उपयोग किए जाते हैं for (foreach) स्टेटमेंट, लिस्ट कॉम्प्रिहेंशन में, और पायथन सिंटैक्स और सिमेंटिक्स # जेनरेटर एक्सप्रेशंस में। पायथन के सभी मानक अंतर्निर्मित संग्रह (अमूर्त डेटा प्रकार) प्रकार पुनरावृत्ति का समर्थन करते हैं, साथ ही कई वर्ग जो मानक पुस्तकालय का हिस्सा हैं। निम्नलिखित उदाहरण एक अनुक्रम पर विशिष्ट अंतर्निहित पुनरावृत्ति दिखाता है:

for value in sequence:
    print(value)

पायथन डिक्शनरी (साहचर्य सरणी का एक रूप) को भी सीधे पुनरावृत्त किया जा सकता है, जब डिक्शनरी कुंजियाँ वापस आती हैं; या items() एक शब्दकोश की विधि को पुनरावृत्त किया जा सकता है जहां यह संबंधित कुंजी, मूल्य जोड़े को टपल के रूप में उत्पन्न करता है:

for key in dictionary:
    value = dictionary[key]
    print(key, value)

for key, value in dictionary.items():
    print(key, value)

हालांकि इटरेटर्स का उपयोग और स्पष्ट रूप से परिभाषित किया जा सकता है। किसी भी पुनरावर्तनीय अनुक्रम प्रकार या वर्ग के लिए, अंतर्निर्मित फ़ंक्शन iter() एक पुनरावर्तक वस्तु बनाने के लिए प्रयोग किया जाता है। इटरेटर ऑब्जेक्ट को इसके साथ पुनरावृत्त किया जा सकता है next() समारोह, जो का उपयोग करता है __next__() विधि आंतरिक रूप से, जो कंटेनर में अगला तत्व लौटाती है। (पिछला कथन Python 3.x पर लागू होता है। Python 2.x में, next() विधि समतुल्य है।) ए StopIteration अपवाद उठाया जाएगा जब कोई और तत्व नहीं छोड़ा जाएगा। निम्नलिखित उदाहरण स्पष्ट पुनरावृत्तियों का उपयोग करते हुए एक अनुक्रम पर एक समान पुनरावृत्ति दिखाता है:

it = iter(sequence)
while True:
    try:
        value = it.next() # in Python 2.x
        value = next(it) # in Python 3.x
    except StopIteration:
        break
    print(value)

कोई भी उपयोगकर्ता-परिभाषित वर्ग एक परिभाषित करके मानक पुनरावृत्ति (या तो अंतर्निहित या स्पष्ट) का समर्थन कर सकता है __iter__() विधि जो एक पुनरावर्तक वस्तु लौटाती है। इटरेटर ऑब्जेक्ट को तब परिभाषित करने की आवश्यकता होती है __next__() विधि जो अगला तत्व लौटाती है।

पायथन के जेनरेटर इस पुनरावृत्ति प्रोटोकॉल (ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग) को लागू करते हैं।

राकु

राकू (प्रोग्रामिंग भाषा) में इटरेटर्स भाषा का मूलभूत हिस्सा हैं, हालांकि आम तौर पर उपयोगकर्ताओं को इटरेटर्स के बारे में परवाह नहीं करना पड़ता है। उनका उपयोग पुनरावृति एपीआई जैसे कि के पीछे छिपा हुआ है for कथन, map, grep, सूची अनुक्रमण के साथ .[$idx], वगैरह।

निम्नलिखित उदाहरण मूल्यों के संग्रह पर विशिष्ट अंतर्निहित पुनरावृत्ति दिखाता है:

my @values = 1, 2, 3;
for @values -> $value {
    say $value
}
# OUTPUT:
# 1
# 2
# 3

राकू हैश को सीधे पुनरावृत्त भी किया जा सकता है; इससे की-वैल्यू प्राप्त होती है Pair वस्तुओं। kv ई> कुंजी और मूल्यों पर पुनरावृति करने के लिए हैश पर विधि लागू की जा सकती है; keys हैश की चाबियों पर पुनरावृति करने की विधि; और यह values विधि हैश के मूल्यों पर पुनरावृति करने के लिए।

my %word-to-number = 'one' => 1, 'two' => 2, 'three' => 3;
for %word-to-number -> $pair {
    say $pair;
}
# OUTPUT:
# three => 3
# one => 1
# two => 2

for %word-to-number.kv -> $key, $value {
    say "$key: $value" 
}
# OUTPUT:
# three: 3
# one: 1
# two: 2

for %word-to-number.keys -> $key {
    say "$key => " ~ %word-to-number{$key};
}
# OUTPUT:
# three => 3
# one => 1
# two => 2

हालांकि इटरेटर्स का उपयोग और स्पष्ट रूप से परिभाषित किया जा सकता है। किसी भी पुनरावर्तनीय प्रकार के लिए, कई विधियाँ हैं जो पुनरावृत्ति प्रक्रिया के विभिन्न पहलुओं को नियंत्रित करती हैं। उदाहरण के लिए, द iterator विधि एक वापस करने के लिए माना जाता है Iterator वस्तु, और pull-one यदि संभव हो तो विधि अगले मूल्य का उत्पादन और वापसी करने वाली है, या प्रहरी मूल्य वापस करने के लिए है IterationEnd यदि कोई और मूल्य उत्पन्न नहीं किया जा सकता है। निम्न उदाहरण स्पष्ट पुनरावर्तकों का उपयोग करके संग्रह पर समकक्ष पुनरावृत्ति दिखाता है:

my @values = 1, 2, 3;
my $it := @values.iterator;          # grab iterator for @values

loop {
    my $value := $it.pull-one;       # grab iteration's next value
    last if $value =:= IterationEnd; # stop if we reached iteration's end
    say $value;
}
# OUTPUT:
# 1
# 2
# 3

Raku में सभी चलने योग्य प्रकार की रचना करते हैं Iterable भूमिका, Iterator भूमिका, या दोनों। Iterable e> काफी सरल है और केवल इसकी आवश्यकता है iterator कंपोजिंग क्लास द्वारा लागू किया जाना है। Iterator e> अधिक जटिल है और विधियों की एक श्रृंखला प्रदान करता है जैसे pull-one, जो कई संदर्भों में पुनरावृति के बेहतर संचालन की अनुमति देता है जैसे कि आइटम जोड़ना या हटाना, या अन्य आइटम तक पहुंचने के लिए उन्हें छोड़ देना। इस प्रकार, कोई भी उपयोगकर्ता परिभाषित वर्ग इन भूमिकाओं को बनाकर और कार्यान्वयन करके मानक पुनरावृत्ति का समर्थन कर सकता है iterator और/या pull-one तरीके। DNA ई> वर्ग एक डीएनए स्ट्रैंड का प्रतिनिधित्व करता है और इसे लागू करता है iterator की रचना करके Iterable भूमिका। जब पुनरावृत्त किया जाता है तो डीएनए स्ट्रैंड ट्रिन्यूक्लियोटाइड्स के समूह में विभाजित हो जाता है:

subset Strand of Str where { .match(/^^ <[ACGT]>+ $$/) and .chars %% 3 };
class DNA does Iterable {
    has $.chain;
    method new(Strand:D $chain) {
        self.bless: :$chain
    }
 
    method iterator(DNA:D:){ $.chain.comb.rotor(3).iterator }
};

for DNA.new('GATTACATA') {
    .say
}
# OUTPUT:
# (G A T)
# (T A C)
# (A T A)

say DNA.new('GATTACATA').map(*.join).join('-');
# OUTPUT:
# GAT-TAC-ATA

Repeater e> वर्ग दोनों की रचना करता है Iterable और Iterator भूमिकाएँ:

class Repeater does Iterable does Iterator {
    has Any $.item  is required;
    has Int $.times is required;
    has Int $!count = 1;
    
    multi method new($item, $times) {
        self.bless: :$item, :$times;
    }
    
    method iterator { self }
    method pull-one(--> Mu){ 
        if $!count <= $!times {
            $!count += 1;
            return $!item
        }
        else {
            return IterationEnd
        }
    }
}

for Repeater.new("Hello", 3) {
    .say
}

# OUTPUT:
# Hello
# Hello
# Hello

रूबी

रूबी पुनरावृत्तियों को काफी अलग तरीके से लागू करती है; सभी पुनरावृत्तियों को कंटेनर विधियों में कॉलबैक क्लोजर पास करने के माध्यम से किया जाता है - इस तरह रूबी न केवल बुनियादी पुनरावृत्ति को लागू करती है, बल्कि फ़ंक्शन मैपिंग, फ़िल्टर और कम करने जैसे पुनरावृत्ति के कई पैटर्न भी लागू करती है। रूबी मूल पुनरावृति विधि के लिए एक वैकल्पिक सिंटैक्स का भी समर्थन करता है each, निम्नलिखित तीन उदाहरण समतुल्य हैं:

(0...42).each do |n|
  puts n
end

...और...

for n in 0...42
  puts n
end

या इससे भी छोटा

42.times do |n|
  puts n
end

रूबी उपयोग करके निश्चित सूचियों पर भी पुनरावृति कर सकती है Enumerators और या तो उन्हें कॉल कर रहे हैं #next विधि या ऊपर के रूप में, उन पर प्रत्येक के लिए कर रहे हैं।

जंग

जंग के साथ कोई भी वैक्टर के तत्व पर पुनरावृति कर सकता है, या स्वयं के पुनरावृत्त बना सकता है। प्रत्येक पुनरावर्तक में एडेप्टर होते हैं (map, filter, skip, take, ...).

for n in 0..42 {
    println!("{}", n);
}

नीचे fibonacci() समारोह एक कस्टम पुनरावर्तक देता है।

for i in fibonacci().skip(4).take(4) {
    println!("{}", i);
}

यह भी देखें

Iteratee, जिसमें, डेवलपर नए मान प्राप्त करने के लिए पुनरावृत्त को बार-बार कॉल करने के बजाय, डेटा के नए भाग को संसाधित करने के लिए पुनरावृति को बार-बार कॉल करता है - नियंत्रण के व्युत्क्रम का एक उदाहरण।
डिजाइन पैटर्न (कंप्यूटर विज्ञान)
पुनरावृत्ति
इटरेटर पैटर्न
रेंज (कंप्यूटर विज्ञान)
आगंतुक पैटर्न
सूचक (कंप्यूटर प्रोग्रामिंग)

संदर्भ

↑ Gatcomb, Joshua. "Understanding and Using Iterators". Perl.com. Archived from the original on 2012-08-06. Retrieved 2012-08-08. A user-defined iterator usually takes the form of a code reference that, when executed, calculates the next item in a list and returns it. When the iterator reaches the end of the list, it returns an agreed-upon value.{{cite web}}: CS1 maint: bot: original URL status unknown (link)
↑ ^2.0 ^2.1 Watt, Stephen M. "A Technique for Generic Iteration and Its Optimization". The University of Western Ontario, Department of Computer Science. Archived from the original on 2012-08-06. Retrieved 2012-08-08. Iterators were introduced as constructs to allow looping over abstract data structures without revealing their internal representation.{{cite web}}: CS1 maint: bot: original URL status unknown (link)
↑ Alex Allain. "STL Iterators". Cprogramming.com - Your resource for C and C++. Retrieved 2012-08-08. You can think of an iterator as pointing to an item that is part of a larger container of items.
↑ ^4.0 ^4.1 "Difference between an external iterator and an internal iterator". CareerRide.COM. 2009-04-03. Archived from the original on 2012-09-19. Retrieved 2012-08-08. An internal iterator is implemented by the member functions of the class which has the iteration logic. An external iterator is implemented by a separate class which can be attached to the object which has iteration logic. The advantage of external iterator is that, many iterators can be made active simultaneously on the existing or same object.{{cite web}}: CS1 maint: bot: original URL status unknown (link)
↑ Watt, Stephen M. "A Technique for Generic Iteration and Its Optimization". The University of Western Ontario, Department of Computer Science. Archived from the original on 2012-08-06. Retrieved 2012-08-08. Some authors use the term iterator, and others the term generator. Some make subtle distinctions between the two.{{cite web}}: CS1 maint: bot: original URL status unknown (link)
↑ ^6.0 ^6.1 Freeman, Eric; Freeman, Elisabeth; Kathy, Sierra; Bert, Bates (2004). Hendrickson, Mike; Loukides, Mike (eds.). Head First Design Patterns (paperback). Vol. 1. O'REILLY. p. 338. ISBN 978-0-596-00712-6. Retrieved 2012-08-09.
↑ "Glossary — Python 3.8.4 documentation". Retrieved 2020-07-15.
↑ Vecerina, Ivan (2006-02-01). "index vs iterator". BYTES. Archived from the original on 2012-08-09. Retrieved 2012-08-08. An index only can be used for containers that (efficiently) support random access (i.e. direct access to an element at a given position). An iterator is a more general concept. Iterators offer efficient traversal of linked lists, files, and a number of other data structures. It often leads to the generation of more efficient code.{{cite web}}: CS1 maint: bot: original URL status unknown (link)
↑ Kevin Waterson. "C++ Iteratoren: Iterator-Kategorien" (in Deutsch). cppreference.com. Retrieved 2012-08-09.
↑ Kevin Waterson. "Iterators: Concepts". sgi. Retrieved 2012-08-09.
↑ larsmans (2011-03-06). "Types of iterator: Output vs. input vs. forward vs. random access iterator". stackoverflow. Archived from the original on 2012-08-08. Retrieved 2012-08-09.{{cite web}}: CS1 maint: bot: original URL status unknown (link)
↑ Kevin Waterson. "Introduction to SPL: Introduction to Standard PHP Library (SPL)". PHPRO.ORG. Retrieved 2012-08-09.
↑ Collier, Andrew. "Iterators in R". Archived from the original on 18 October 2018. Retrieved 16 November 2013.
↑ "concurrent_unordered_set Template Class". Intel Threading Building Blocks for Open Source. Archived from the original on 2015-05-01. Retrieved 2012-08-09. •The iterator types iterator and const_iterator are of the forward iterator category
↑ ^15.0 ^15.1 ^15.2 ^15.3 ^15.4 Albahari, Joseph. संक्षेप में सी # 10. O'Reilly. ISBN 978-1-098-12195-2.
↑ ^16.0 ^16.1 ^16.2 ^16.3 ^16.4 Skeet, Jon. सी # गहराई में. Manning. ISBN 978-1617294532.
↑ ^17.0 ^17.1 ^17.2 ^17.3 ^17.4 Price, Mark J. C# 8.0 and .NET Core 3.0 – Modern Cross-Platform Development: Build Applications with C#, .NET Core, Entity Framework Core, ASP.NET Core, and ML.NET Using Visual Studio Code. Packt. ISBN 978-1-098-12195-2.
↑ ^18.0 ^18.1 ^18.2 ^18.3 ^18.4 ^18.5 ^18.6 Bloch, Joshua (2018). "Effective Java: Programming Language Guide" (third ed.). Addison-Wesley. ISBN 978-0134685991.
↑ "java.util: Interface Iterator<E>: Method Summary". Oracle. Retrieved 2012-08-08.
↑ "PHP 4 ChangeLog". The PHP Group. 2000-02-20. Retrieved 2015-10-13.
↑ Internal refers to the fact that the interface cannot be implemented in PHP scripts, only in the C (programming language) source.
↑ "The Traversable interface". The PHP Group. Retrieved 2015-10-13.
↑ "Iterators". The PHP Group. Retrieved 2015-10-13.
↑ "PHP 5 ChangeLog". The PHP Group. 2013-06-20. Retrieved 2015-10-13.

बाहरी संबंध

Java's Iterator, Iterable and ListIterator Explained
.NET interface
Article "Understanding and Using Iterators" by Joshua Gatcomb
Article "A Technique for Generic Iteration and Its Optimization" (217 KB) by Stephen M. Watt
Iterators
Boost C++ Iterator Library
Java interface
PHP: Object Iteration
STL Iterators
What are iterators? - Reference description

[1] Gatcomb, Joshua. "Understanding and Using Iterators". Perl.com. Archived from the original on 2012-08-06. Retrieved 2012-08-08. A user-defined iterator usually takes the form of a code reference that, when executed, calculates the next item in a list and returns it. When the iterator reaches the end of the list, it returns an agreed-upon value.{{cite web}}: CS1 maint: bot: original URL status unknown (link)

[definition-2] 2.0 ^2.1 Watt, Stephen M. "A Technique for Generic Iteration and Its Optimization". The University of Western Ontario, Department of Computer Science. Archived from the original on 2012-08-06. Retrieved 2012-08-08. Iterators were introduced as constructs to allow looping over abstract data structures without revealing their internal representation.{{cite web}}: CS1 maint: bot: original URL status unknown (link)

[3] Alex Allain. "STL Iterators". Cprogramming.com - Your resource for C and C++. Retrieved 2012-08-08. You can think of an iterator as pointing to an item that is part of a larger container of items.

[ExternalInternal-4] 4.0 ^4.1 "Difference between an external iterator and an internal iterator". CareerRide.COM. 2009-04-03. Archived from the original on 2012-09-19. Retrieved 2012-08-08. An internal iterator is implemented by the member functions of the class which has the iteration logic. An external iterator is implemented by a separate class which can be attached to the object which has iteration logic. The advantage of external iterator is that, many iterators can be made active simultaneously on the existing or same object.{{cite web}}: CS1 maint: bot: original URL status unknown (link)

[5] Watt, Stephen M. "A Technique for Generic Iteration and Its Optimization". The University of Western Ontario, Department of Computer Science. Archived from the original on 2012-08-06. Retrieved 2012-08-08. Some authors use the term iterator, and others the term generator. Some make subtle distinctions between the two.{{cite web}}: CS1 maint: bot: original URL status unknown (link)

[HFDPIterators-6] 6.0 ^6.1 Freeman, Eric; Freeman, Elisabeth; Kathy, Sierra; Bert, Bates (2004). Hendrickson, Mike; Loukides, Mike (eds.). Head First Design Patterns (paperback). Vol. 1. O'REILLY. p. 338. ISBN 978-0-596-00712-6. Retrieved 2012-08-09.

[7] "Glossary — Python 3.8.4 documentation". Retrieved 2020-07-15.

[8] Vecerina, Ivan (2006-02-01). "index vs iterator". BYTES. Archived from the original on 2012-08-09. Retrieved 2012-08-08. An index only can be used for containers that (efficiently) support random access (i.e. direct access to an element at a given position). An iterator is a more general concept. Iterators offer efficient traversal of linked lists, files, and a number of other data structures. It often leads to the generation of more efficient code.{{cite web}}: CS1 maint: bot: original URL status unknown (link)

[9] Kevin Waterson. "C++ Iteratoren: Iterator-Kategorien" (in Deutsch). cppreference.com. Retrieved 2012-08-09.

[10] Kevin Waterson. "Iterators: Concepts". sgi. Retrieved 2012-08-09.

[11] rsmans (2011-03-06). "Types of iterator: Output vs. input vs. forward vs. random access iterator". stackoverflow. Archived from the original on 2012-08-08. Retrieved 2012-08-09.{{cite web}}: CS1 maint: bot: original URL status unknown (link)

[12] Kevin Waterson. "Introduction to SPL: Introduction to Standard PHP Library (SPL)". PHPRO.ORG. Retrieved 2012-08-09.

[13] Collier, Andrew. "Iterators in R". Archived from the original on 18 October 2018. Retrieved 16 November 2013.

[14] "concurrent_unordered_set Template Class". Intel Threading Building Blocks for Open Source. Archived from the original on 2015-05-01. Retrieved 2012-08-09. •The iterator types iterator and const_iterator are of the forward iterator category

[Albahari-15] 15.0 ^15.1 ^15.2 ^15.3 ^15.4 Albahari, Joseph. संक्षेप में सी # 10. O'Reilly. ISBN 978-1-098-12195-2.

[Skeet-16] 16.0 ^16.1 ^16.2 ^16.3 ^16.4 Skeet, Jon. सी # गहराई में. Manning. ISBN 978-1617294532.

[Price-17] 17.0 ^17.1 ^17.2 ^17.3 ^17.4 Price, Mark J. C# 8.0 and .NET Core 3.0 – Modern Cross-Platform Development: Build Applications with C#, .NET Core, Entity Framework Core, ASP.NET Core, and ML.NET Using Visual Studio Code. Packt. ISBN 978-1-098-12195-2.

[Bloch-18] 18.0 ^18.1 ^18.2 ^18.3 ^18.4 ^18.5 ^18.6 Bloch, Joshua (2018). "Effective Java: Programming Language Guide" (third ed.). Addison-Wesley. ISBN 978-0134685991.

[19] "java.util: Interface Iterator<E>: Method Summary". Oracle. Retrieved 2012-08-08.

[20] "PHP 4 ChangeLog". The PHP Group. 2000-02-20. Retrieved 2015-10-13.

[21] Internal refers to the fact that the interface cannot be implemented in PHP scripts, only in the C (programming language) source.

[22] "The Traversable interface". The PHP Group. Retrieved 2015-10-13.

[23] "Iterators". The PHP Group. Retrieved 2015-10-13.

[24] "PHP 5 ChangeLog". The PHP Group. 2013-06-20. Retrieved 2015-10-13.

[1]

[2]

[3]

[4]

[5]

[6]

[7]

[8]

[9]

[10]

[11]

[12]

[13]

[14]

[15]

[16]

[17]

[18]

[19]

[20]

[21]

[22]

[23]

[24]