المُكرِّر

تُسمى المُكرِّرات في إطار عمل .NETIEnumerator (أي C#) "المُعدِّدات" ويتم تمثيلها بواسطة الواجهة. ^{[ 17 ] : 189-190، 344 [ 18 ] : 53-54}IEnumerator تُوفر MoveNext()طريقةً للانتقال إلى العنصر التالي وتُشير إلى ما إذا تم الوصول إلى نهاية المجموعة؛ ^{[ 17 ] : 344 [ 18 ] : 55-56 [ 19 ] : 89} خاصيةً Currentللحصول على قيمة العنصر الذي يُشير إليه المؤشر حاليًا؛ ^{[ 17 ] : 344 [ 18 ] : 56 [ 19 ] : 89} وطريقةً اختياريةً Reset()، ^{[ 17 ] : 344} لإعادة المُعدِّد إلى موضعه الأولي. يُشير المُعدِّد في البداية إلى قيمة خاصة قبل العنصر الأول، لذا يلزم استدعاء هذه الطريقة MoveNext()لبدء التكرار.

عادةً ما يتم الحصول على المُعدِّدات باستدعاء GetEnumerator()دالة كائن يُطبِّق الواجهة IEnumerable. ^{[ 18 ] : 54-56 [ 19 ] : 54-56} خاصية Current، للحصول على قيمة العنصر الذي يُشار إليه حاليًا؛ ^{[ 17 ] : 344 [ 18 ] : 56 [ 19 ] : 89} تُطبِّق فئات الحاويات عادةً هذه الواجهة. مع ذلك، يمكن لعبارة foreach في لغة C# أن تعمل على أي كائن يُوفِّر مثل هذه الدالة، حتى لو لم يُطبِّقها IEnumerable( الكتابة الديناميكية ). ^{[ 19 ] : 89} تم توسيع كلتا الواجهتين إلى إصدارات عامة في .NET 2.0 .

يوضح المثال التالي استخدامًا بسيطًا للمكررات في لغة C# 2.0:

باستخدام System ؛ باستخدام System.Collections.Generic ؛// نسخة صريحة IEnumerator <MyType> iter = list.GetEnumerator ( ) ; while ( iter.MoveNext ( ) ) { Console.WriteLine ( iter.Current ) ; }​​​// النسخة الضمنية foreach ( MyType value in list ) { Console . WriteLine ( value ); }

يدعم C# 2.0 أيضًا المولدات : الطريقة التي يتم تعريفها على أنها تُرجع IEnumerator(أو IEnumerable)، ولكنها تستخدم yield returnعبارة " " لإنتاج سلسلة من العناصر بدلاً من إرجاع مثيل كائن، سيتم تحويلها بواسطة المترجم إلى فئة جديدة تُنفذ الواجهة المناسبة.

لا توجد المكررات بشكل أصلي في لغة C ، ولكن يمكن محاكاتها إلى حد ما باستخدام حساب المؤشرات .

يوضح المثال التالي قائمة مرتبطة intمع مُكرِّر.

typedef struct LinkedList { int * value ; struct LinkedList * next ; } LinkedList ;typedef struct { LinkedList * current ; } LinkedListIterator ;LinkedListIterator list_begin ( LinkedList * head ) { LinkedListIterator it = { head }; return it ; }int * list_next ( LinkedListIterator * it ) { if ( ! it -> current ) { return NULL ; } int * value = & it -> current -> value ; it -> current = it -> current -> next ; return value ; }int main () { // ... for ( LinkedListIterator it = list_begin ( head ); ; ) { int * val = list_next ( & it ); if ( ! val ) { break ; } printf ( "%d \n " , * val ); } }

تستخدم لغة C++ المُكرِّرات على نطاق واسع في مكتبتها القياسية ، وتصف عدة فئات منها تختلف في نطاق العمليات التي تسمح بها. تشمل هذه الفئات المُكرِّرات الأمامية ، والمُكرِّرات ثنائية الاتجاه ، ومُكرِّرات الوصول العشوائي ، مرتبةً حسب تزايد إمكانياتها. توفر جميع أنواع قوالب الحاويات القياسية مُكرِّرات من إحدى هذه الفئات. تُعمِّم المُكرِّرات المؤشرات إلى عناصر المصفوفة (والتي يمكن استخدامها بالفعل كمُكرِّرات)، وقد صُمِّم تركيبها ليُشابه تركيب حساب المؤشرات في لغة C ، حيث تُستخدم المعاملات ` and` للإشارة إلى العنصر الذي يُشير إليه المُكرِّر، وتُستخدم معاملات حساب المؤشرات `x` و`y` لتعديل المُكرِّرات أثناء اجتياز الحاوية.*->++

تتضمن عملية اجتياز النطاق باستخدام المُكرِّرات عادةً مُكرِّرًا واحدًا متغيرًا، ومُكرِّرين ثابتين يُستخدمان لتحديد نطاق النطاق المراد اجتيازه. المسافة بين المُكرِّرين، من حيث عدد مرات تطبيق المُعامل ++اللازم لتحويل الحد الأدنى إلى الحد الأعلى، تُساوي عدد العناصر في النطاق المُحدد؛ وعدد قيم المُكرِّر المختلفة يزيد بواحد عن ذلك. اصطلاحًا، يُشير المُكرِّر الأدنى إلى العنصر الأول في النطاق، بينما لا يُشير المُكرِّر الأعلى إلى أي عنصر في النطاق، بل إلى ما بعد نهايته مباشرةً. لاجتياز حاوية كاملة، begin()تُوفر الدالة الحد الأدنى والحد end()الأعلى. لا يُشير الحد الأعلى إلى أي عنصر من عناصر الحاوية، ولكنه قيمة مُكرِّر صالحة يُمكن مُقارنتها.

يوضح المثال التالي استخدامًا نموذجيًا للمكرر.

استيراد std ؛باستخدام std :: vector ;int main () { vector < int > items ; items . push_back ( 5 ); // إضافة القيمة العددية '5' إلى المتجه 'items'. items . push_back ( 2 ); // إضافة القيمة العددية '2' إلى المتجه 'items'. items . push_back ( 9 ); // إضافة القيمة العددية '9' إلى المتجه 'items'.// التكرار عبر 'items'. // 'it' من النوع vector<int>::iterator for ( auto it = items . begin (), end = items . end (); it != end ; ++ it ) { // وطباعة قيمة 'items' للفهرس الحالي. std :: print ( "{}" , * it ); }// باستخدام حلقات foreach (المضافة في C++11)، // يمكن فعل الشيء نفسه دون استخدام أي مُكرِّرات صريحة: for ( int x : items ) { // طباعة قيمة كل عنصر 'x' من 'items'. std :: print ( "{}" , x ); }// كلا حلقتي التكرار تطبعان "529". }

أنواع المُكرِّرات منفصلة عن أنواع الحاويات التي تُستخدم معها، على الرغم من أنهما يُستخدمان غالبًا معًا. يعتمد تصنيف المُكرِّر (وبالتالي العمليات المُعرَّفة له) عادةً على نوع الحاوية، حيث تُوفِّر المصفوفات أو المتجهات، على سبيل المثال، مُكرِّرات وصول عشوائي، بينما تُوفِّر المجموعات (التي تستخدم بنية مرتبطة كتنفيذ) مُكرِّرات ثنائية الاتجاه فقط. يمكن أن يكون لنوع حاوية واحد أكثر من نوع مُكرِّر مرتبط به؛ على سبيل المثال، std::vector<T>يسمح نوع الحاوية بالتنقل إما باستخدام مؤشرات (أولية) إلى عناصره (من النوع T*)، أو قيم من نوع خاص std::vector<T>::iterator، وهناك نوع آخر مُخصَّص لـ "المُكرِّرات العكسية"، التي تُعرَّف عملياتها بطريقة تجعل الخوارزمية التي تُنفِّذ تنقلًا عاديًا (أماميًا) تُنفِّذ التنقل بترتيب عكسي عند استدعائها باستخدام مُكرِّرات عكسية. تُوفِّر معظم الحاويات أيضًا const_iteratorنوعًا منفصلًا، لا تُعرَّف له عمدًا العمليات التي تسمح بتغيير القيم المُشار إليها.

const_iteratorيمكن إجراء اجتياز بسيط لكائن حاوية أو نطاق من عناصره (بما في ذلك تعديل تلك العناصر ما لم يتم استخدام `a` ) باستخدام المُكرِّرات فقط. ولكن قد توفر أنواع الحاويات أيضًا طرقًا مثل `return` insertأو ` erasereturn` التي تُعدِّل بنية الحاوية نفسها؛ هذه طرق خاصة بفئة الحاوية، ولكنها تتطلب بالإضافة إلى ذلك قيمة مُكرِّر واحدة أو أكثر لتحديد العملية المطلوبة. على الرغم من أنه من الممكن أن تشير مُكرِّرات متعددة إلى نفس الحاوية في وقت واحد، إلا أن عمليات تعديل البنية قد تُبطل بعض قيم المُكرِّرات (يُحدد المعيار لكل حالة ما إذا كان هذا ممكنًا أم لا)؛ استخدام مُكرِّر مُبطل يُعد خطأً سيؤدي إلى سلوك غير مُعرَّف ، ولا يلزم أن يُشير نظام وقت التشغيل إلى مثل هذه الأخطاء.

كما يدعم C++ التكرار الضمني جزئيًا من خلال استخدام قوالب الدوال القياسية، std::for_each()مثل std::copy() و std::accumulate().

عند استخدامها، يجب تهيئتها باستخدام مُكرِّرات موجودة، عادةً `x` beginو`y` end، والتي تُحدد النطاق الذي يتم التكرار عليه. ولكن لا يتم عرض أي كائن مُكرِّر صريح لاحقًا أثناء تقدم عملية التكرار. يُوضح هذا المثال استخدام `x` for_each.

// أي نوع حاوية قياسي لعناصر ItemType. ContainerType < ItemType > c ;// دالة تعالج كل عنصر من عناصر المجموعة. void processItem ( const ItemType & i ) { std :: println ( "{}" , i ); }// حلقة تكرار for-each. std :: for_each ( c.begin ( ), c.end ( ), processItem ) ; // باستخدام std::ranges: std :: ranges :: for_each ( c , processItem );

ويمكن تحقيق نفس النتيجة باستخدام std::copy، مع تمرير std::ostream_iteratorقيمة كمكرر ثالث:

باستخدام std :: cout ؛ باستخدام std :: ostream_iterator ؛std :: copy ( c.begin ( ) , c.end ( ), ostream_iterator <ItemType> ( cout , " \n " ) ) ; // باستخدام std::ranges: std :: ranges :: copy ( c , ostream_iterator <ItemType> ( cout , " \ n " ) );

منذ إصدار C++11 ، أصبح بالإمكان استخدام صيغة دالة لامدا لتحديد العملية المراد تكرارها مباشرةً، مما يُغني عن الحاجة إلى تعريف دالة مُسماة. إليك مثال على تكرار حلقة for-each باستخدام دالة لامدا:

ContainerType < ItemType > c ; // أي نوع حاوية قياسي لعناصر ItemType.// حلقة تكرارية for-each مع دالة لامدا. std :: for_each ( c.begin ( ), c.end ( ) , [ ] ( const ItemType & i ) -> void { std :: println ( "{}" , i ); });// باستخدام std::ranges: std :: ranges :: for_each ( c , []( const ItemType & i ) -> void { std :: println ( "{}" , i ); });

يمكن تطبيق صيغة Java الخاصة بالمكررات ( Iterator<T>, vs T::iterator) في لغة C++ بالطريقة التالية:

استيراد std ؛namespace { // مفهوم مساعد: إذا كان يحتوي على مُكرِّر template < typename T > concept Has_iterator = requires { typename T :: iterator }; }template < typename Iterable > requires Has_iterator < Iterable > using Iterator = typename Iterable :: iterator ;// يمكن الآن استدعاؤها على النحو التالي:template < typename T > using Vector = std :: vector < T > ;int main () { Vector < int > v { 1 , 2 , 3 , 4 , 5 }; for ( Iterator < Vector < int >> it = v . begin (); it != v . end (); ++ it ) { std :: println ( "{}" , * it ); } }

تتيح هذه الواجهة، التي طُرحت في إصدار Java JDK 1.2، java.util.Iteratorإمكانية تكرار فئات الحاويات. Iteratorتوفر كل فئة طريقةً next()ودالةً hasNext()، ^{[ 20 ] : 294-295} ، وقد تدعم اختياريًا طريقةً أخرى، remove()^{[ 20 ] : 262، 266.} تُنشأ المُكرِّرات بواسطة فئة الحاوية المُقابلة، عادةً بواسطة دالة تُسمى iterator(). ^{[ 21 ] [ 20 ] : 99 [ 20 ] : 217}

تُحرك هذه next()الطريقة المؤشر وتُعيد القيمة التي يُشير إليها. يتم الحصول على العنصر الأول عند أول استدعاء لها next(). ^{[ 20 ] : 294-295.} لتحديد متى تمت زيارة جميع العناصر في الحاوية، hasNext()تُستخدم طريقة الاختبار. ^{[ 20 ] : 262.} يُوضح المثال التالي استخدامًا بسيطًا للمُكررات:

استيراد java.util.Iterator ؛Iterator iter = list.iterator ( ) ; Iterator <MyType> iter = list.iterator ( ); // Iterator iter = list.iterator( ) ; قبل J2SE 5.0 while ( iter.hasNext ( ) ) { System.out.print ( iter.next ( ) ) ; if ( iter.hasNext ( ) ) { System.out.print ( " , " ) ; } }

ولإظهار أنه hasNext()يمكن استدعاء ذلك بشكل متكرر، نستخدمه لإدراج الفواصل بين العناصر ولكن ليس بعد العنصر الأخير.

لا يفصل هذا الأسلوب عملية التقدم عن الوصول الفعلي إلى البيانات بشكل صحيح. إذا كان يجب استخدام عنصر البيانات أكثر من مرة لكل عملية تقدم، فيجب تخزينه في متغير مؤقت . عند الحاجة إلى التقدم دون الوصول إلى البيانات (أي لتجاوز عنصر بيانات معين)، يتم الوصول إلى البيانات على أي حال، مع تجاهل القيمة المُعادة في هذه الحالة.

بالنسبة لأنواع المجموعات التي تدعم هذه الخاصية، remove()تقوم دالة المُكرِّر بإزالة العنصر الذي تمت زيارته مؤخرًا من الحاوية مع الحفاظ على إمكانية استخدام المُكرِّر. يؤدي إضافة أو إزالة عناصر عن طريق استدعاء دوال الحاوية (حتى من نفس سلسلة العمليات ) إلى جعل المُكرِّر غير قابل للاستخدام. محاولة الحصول على العنصر التالي تُطلق استثناءً. كما يُطلق استثناء أيضًا في حال عدم وجود عناصر متبقية (إذا hasNext()كانت الدالة قد أعادت القيمة false سابقًا).

بالإضافة إلى ذلك، java.util.Listهناك java.util.ListIteratorواجهة برمجة تطبيقات مماثلة تسمح بالتكرار الأمامي والخلفي، وتوفر فهرسها الحالي في القائمة وتسمح بتعيين عنصر القائمة في موضعه.

قدّم إصدار J2SE 5.0 من Java Iterableواجهةً لدعم حلقة for( foreach ) مُحسّنة للتكرار على المجموعات والمصفوفات. Iterableتُعرّف هذه iterator()الواجهة الطريقة التي تُعيد قيمةً Iterator. ^{[ 20 ] : 266} باستخدام الحلقة المُحسّنة for، يُمكن إعادة كتابة المثال السابق على النحو التالي:

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

تستخدم بعض الحاويات أيضًا الفئة الأقدم (منذ الإصدار 1.0) Enumeration. توفر هذه الفئة طرقًا hasMoreElements()، nextElement()ولكنها لا تحتوي على طرق لتعديل الحاوية.

في لغة سكالا ، تتمتع المُكرِّرات بمجموعة غنية من الدوال المشابهة للمجموعات، ويمكن استخدامها مباشرةً في حلقات التكرار. في الواقع، ترث كل من المُكرِّرات والمجموعات سمة أساسية مشتركة scala.collection.TraversableOnce. مع ذلك، ونظرًا لغنى مكتبة المجموعات في سكالا بالدوال المتاحة، مثل map`require` collectو` filterrequire` وغيرها، فغالبًا لا يكون من الضروري التعامل مع المُكرِّرات مباشرةً عند البرمجة بلغة سكالا.

يمكن تحويل مُكرِّرات ومجموعات Java تلقائيًا إلى مُكرِّرات ومجموعات Scala، على التوالي، ببساطة عن طريق إضافة سطر واحد.

import scala.collection.JavaConversions._​​​​​​

إلى الملف. JavaConversionsيوفر الكائن تحويلات ضمنية للقيام بذلك. التحويلات الضمنية هي إحدى ميزات لغة سكالا: وهي عبارة عن دوال، عندما تكون مرئية في النطاق الحالي، تُدرج تلقائيًا استدعاءات لنفسها في التعبيرات ذات الصلة في المكان المناسب لجعلها قابلة للتحقق من النوع عندما لا تكون كذلك في الأحوال العادية.

يدعم MATLAB التكرار الضمني الخارجي والداخلي باستخدام المصفوفات الأصلية أو cellالمصفوفات. في حالة التكرار الخارجي، حيث تقع مسؤولية التقدم في عملية التصفح وطلب العناصر التالية على عاتق المستخدم، يمكن تعريف مجموعة من العناصر ضمن بنية تخزين مصفوفة، ثم التصفح بين هذه العناصر باستخدام forبنية الحلقة. على سبيل المثال،

% تعريف مصفوفة من الأعداد الصحيحة myArray = [ 1 , 3 , 5 , 7 , 11 , 13 ];for n = myArray % ... do something with n disp ( n ) % Echo in the Command Window end

يجتاز مصفوفة من الأعداد الصحيحة باستخدام الكلمة forالمفتاحية.

في حالة التكرار الداخلي، حيث يُمكن للمستخدم تحديد عملية للمُكرِّر لتنفيذها على كل عنصر من عناصر المجموعة، يتم تحميل العديد من المعاملات ووظائف MATLAB المُدمجة لتنفيذها على كل عنصر من عناصر المصفوفة وإرجاع مصفوفة إخراج مُطابقة ضمنيًا. علاوة على ذلك، يُمكن الاستفادة من الدالتين arrayfun`and` cellfunلتنفيذ عمليات مُخصصة أو مُعرَّفة من قِبل المستخدم على المصفوفات الأصلية والمصفوفات cellالمُعرَّفة على التوالي. على سبيل المثال،

دالة simpleFun % تعريف مصفوفة من الأعداد الصحيحة myArray = [ 1 , 3 , 5 , 7 , 11 , 13 ];% قم بتنفيذ عملية مخصصة على كل عنصر myNewArray = arrayfun (@( a ) myCustomFun ( a ), myArray );% اطبع المصفوفة الناتجة في نافذة الأوامر myNewArrayدالة outScalar = myCustomFun ( inScalar ) % ببساطة اضرب في 2 outScalar = 2 * inScalar ;

تُعرّف دالة أساسية simpleFunتقوم ضمنيًا بتطبيق دالة فرعية مخصصة myCustomFunعلى كل عنصر من عناصر المصفوفة باستخدام دالة مدمجة arrayfun.

بدلاً من ذلك، قد يكون من المستحسن تجريد آليات حاوية تخزين المصفوفة عن المستخدم من خلال تعريف تطبيق MATLAB مخصص كائني التوجه لنمط المُكرِّر. يُوضَّح هذا التطبيق، الذي يدعم التكرار الخارجي، في عنصر " نمط التصميم: المُكرِّر (السلوكي)" في MATLAB Central File Exchange . كُتِبَ هذا التطبيق باستخدام صيغة تعريف الفئة الجديدة المُقدَّمة مع إصدار برنامج MATLAB 7.6 (R2008a)، ويتميز cellبتحقيق مصفوفة أحادية البُعد لنوع بيانات القائمة المجردة (ADT) كآلية لتخزين مجموعة غير متجانسة (من حيث نوع البيانات) من العناصر. يوفر هذا التطبيق وظائف اجتياز القائمة الأمامي الصريح باستخدام طرق `include` hasNext()و` include` next()و` reset()include` للاستخدام في whileحلقة `include`.

foreachتم تقديم حلقة التكرار في PHP في الإصدار 4.0، وأصبحت متوافقة مع الكائنات كقيم في الإصدار التجريبي 4.0 بيتا 4. ^{[ 22 ]} ومع ذلك، أُضيف دعم المُكرِّرات في PHP  5 من خلال تقديم الواجهة الداخلية ^{[ 23 ]}Traversable . ^{[ 24 ]} الواجهتان الرئيسيتان للتنفيذ في نصوص PHP التي تُمكِّن من تكرار الكائنات عبر foreachحلقة التكرار هما `input` Iteratorو`input` IteratorAggregate. لا تتطلب الأخيرة من الفئة المُنفِّذة تعريف جميع الطرق المطلوبة، بل تُنفِّذ طريقة وصولgetIterator (`accessor` ) تُعيد نسخة من `input` Traversable. توفر مكتبة PHP القياسية عدة فئات للعمل مع المُكرِّرات الخاصة. ^{[ 25 ]} يدعم PHP أيضًا المُولِّدات منذ الإصدار 5.5. ^{[ 26 ]}

أبسط طريقة للتنفيذ هي عن طريق تغليف مصفوفة، وهذا يمكن أن يكون مفيدًا للتلميح إلى النوع وإخفاء المعلومات .

namespace Wikipedia\Iterator ;الفئة النهائية ArrayIterator تمتد من \Iterator { مصفوفة خاصة $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 كاملة foreach ($iterator as $key => $current) {}. تُنفذ طرق المُكرِّر بالترتيب التالي:

1. $iterator->rewind()يضمن ذلك أن يبدأ الهيكل الداخلي من البداية.
2. $iterator->valid()في هذا المثال، تكون النتيجة صحيحة .
3. $iterator->current()يتم تخزين القيمة المُعادة في $value.
4. $iterator->key()يتم تخزين القيمة المُعادة في $key.
5. $iterator->next()ينتقل إلى العنصر التالي في البنية الداخلية.
6. $iterator->valid()تُرجع الدالة القيمة false ويتم إيقاف الحلقة.

يوضح المثال التالي فئة 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' );// تُنفّذ فئة `mysqli_result` المُعادة من استدعاء الدالة واجهة Traversable الداخلية. foreach ( $mysqli -> query ( 'SELECT `a`, `b`, `c` FROM `table`' , MYSQLI_USE_RESULT ) as $row ) { // تنفيذ الإجراء على الصف المُعاد، وهو عبارة عن مصفوفة ترابطية. }

تُعدّ المُكرِّرات في بايثون جزءًا أساسيًا من اللغة، وفي كثير من الأحيان لا تُرى لأنها تُستخدم ضمنيًا في عبارة 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__()داخليًا الطريقة التي تُعيد العنصر التالي في الحاوية. (ينطبق البيان السابق على بايثون 3.x. في بايثون 2.x، next()تكون الطريقة مُكافئة). StopIterationسيتم طرح استثناء عند عدم وجود عناصر متبقية. يُظهر المثال التالي تكرارًا مُكافئًا على تسلسل باستخدام مُكرِّرات صريحة:

من typing استورد Iteratorsequence : list [ int ] = [ 1 , 2 , 3 , 4 ] it : Iterator [ int ] = iter ( sequence ) while True : try : value = it.next ( ) # في بايثون 2.x value = next ( it ) # في بايثون 3.x except StopIteration : break print ( value )

يمكن لأي فئة معرفة من قبل المستخدم أن تدعم التكرار القياسي (سواء كان ضمنيًا أو صريحًا) عن طريق تعريف __iter__()دالة تُرجع كائنًا مُكرِّرًا. ثم يحتاج الكائن المُكرِّر إلى تعريف __next__()دالة تُرجع العنصر التالي.

تُنفذ مولدات بايثون بروتوكول التكرار هذا .

تُعدّ المُكرِّرات في لغة Raku جزءًا أساسيًا منها، مع أن المستخدمين عادةً لا يحتاجون إلى الاهتمام بها. يتم إخفاء استخدامها خلف واجهات برمجة تطبيقات التكرار، مثل عبارة `return` for، mapو` grepreturn`، وفهرسة القوائم باستخدام `return` .[$idx]، وما إلى ذلك.

يوضح المثال التالي عملية التكرار الضمني النموذجية على مجموعة من القيم:

my @values ​​= 1 , 2 , 3 ; for @values ​​-> $value { say $value } المخرجات: 1 2 3

يمكن أيضًا تكرار عناصر التجزئة في Raku مباشرةً، مما ينتج عنه Pairكائنات مفتاح-قيمة. kvيمكن استدعاء الدالة على التجزئة للتكرار على المفتاح والقيم؛ keysوالدالة للتكرار على مفاتيح التجزئة؛ والدالة valuesللتكرار على قيم التجزئة.

my %word-to-number = 'one' => 1 , 'two' => 2 , 'three' => 3 ; for %word-to-number -> $pair { say $pair ; } الناتج: ثلاثة => 3 واحد => 1 اثنان => 2for %word-to-number . kv -> $key , $value { say "$key: $value" } الناتج: ثلاثة: 3 واحد: 1 اثنان: 2for %word-to-number . keys -> $key { say "$key => " ~ %word-to-number { $key }; } الناتج: ثلاثة => 3 واحد => 1 اثنان => 2

مع ذلك، يمكن استخدام المُكرِّرات وتحديدها بشكل صريح. بالنسبة لأي نوع قابل للتكرار، توجد عدة طرق تتحكم في جوانب مختلفة من عملية التكرار. على سبيل المثال، iteratorمن المفترض أن تُعيد الطريقة Iteratorكائنًا، ومن pull-oneالمفترض أن تُنتج الطريقة التالية وتُعيدها إن أمكن، أو تُعيد القيمة المرجعيةIterationEnd إذا لم يكن بالإمكان إنتاج المزيد من القيم. يُوضح المثال التالي تكرارًا مُكافئًا على مجموعة باستخدام مُكرِّرات صريحة:

my @values ​​= 1 , 2 , 3 ; my $it := @values.iterator ; # الحصول على مُكرِّر @valuesloop { my $value := $it . pull-one ; # الحصول على القيمة التالية للتكرار أخيرًا if $value =:= IterationEnd ; # التوقف إذا وصلنا إلى نهاية التكرار say $value ; } المخرجات: 1 2 3

تُشكّل جميع الأنواع القابلة للتكرار في راكو Iterableالدور، أو Iteratorالدور، أو كليهما. الدور الأول Iterableبسيط للغاية، ولا يتطلب سوى iteratorتنفيذه بواسطة الفئة المُكوِّنة. أما الدور الثاني Iteratorفهو أكثر تعقيدًا، ويُوفّر سلسلة من الطرق مثل pull-one، مما يسمح بعملية تكرار أدق في سياقات متعددة، كإضافة العناصر أو حذفها، أو تخطيها للوصول إلى عناصر أخرى. بالتالي، يُمكن لأي فئة مُعرَّفة من قِبل المستخدم دعم التكرار القياسي من خلال تكوين هذه الأدوار وتنفيذ طرق iteratorو/أو pull-one.

يمثل هذا DNAالصنف شريط الحمض النووي (DNA) وينفذه iteratorمن خلال تكوين Iterableالدور. يتم تقسيم شريط الحمض النووي إلى مجموعة من ثلاثيات النوكليوتيدات عند تكراره على:

مجموعة فرعية Strand من Str حيث { . match ( /^^ <[ACGT]>+ $$/ ) و . chars %% 3 }; فئة DNA تقوم بـ Iterable { لديها $.chain ; طريقة new ( Strand:D $chain ) { self . bless: : $chain } method iterator ( DNA:D: ){ $.chain . comb . rotor ( 3 ). iterator } }; للحمض النووي . جديد ( 'جاتاكاتا' ) { . يقول } المخرجات: (GAT) (TAC) (ATA)قل DNA.new ( ' GATTACATA' ). map ( *. join ) .join ( '-' ); # الناتج: # GAT-TAC-ATA

يشمل هذا Repeaterالصنف كلا 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 ; } دالة iterator { self } دالة pull-one (--> Mu ){ إذا كان $!count <= $!times { $!count += 1 ; return $!item } وإلا { أعد نهاية التكرار } } } for Repeater.new ( "Hello " , 3 ) { . يقول } المخرجات: مرحباً مرحباً مرحباً

تُنفّذ لغة روبي المُكرِّرات بطريقة مختلفة تمامًا؛ إذ تتم جميع عمليات التكرار عن طريق تمرير دوال رد نداء إلى دوال الحاوية. وبهذه الطريقة، لا تُنفّذ روبي التكرار الأساسي فحسب، بل تُنفّذ أيضًا أنماطًا متعددة من التكرار مثل تعيين الدوال، والمرشحات، والاختزال. كما تدعم روبي صيغة بديلة لطريقة التكرار الأساسية each، والأمثلة الثلاثة التالية متكافئة:

( 0 ... 42 ) . كل حلقة كرر | ن | ضع ن نهاية

...و...

for n in 0 ... 42 puts n end

أو حتى أقصر

٤٢. مرات do | n | puts n end​

يمكن لـ Ruby أيضًا التكرار على القوائم الثابتة باستخدام Enumerators إما عن طريق استدعاء طريقتها #nextأو القيام بـ for each عليها، كما هو موضح أعلاه.

تستخدم لغة Rust المُكرِّرات الخارجية في جميع أنحاء المكتبة القياسية، بما في ذلك في forحلقة التكرار الخاصة بها، والتي تستدعي ضمنيًا دالة المُكرِّر حتى يتم استهلاكها. على سبيل المثال، تقوم next()أبسط حلقة تكرار بالتكرار على نوع معين:forRange

for i in 0 .. 42 { println! ( "{}" , i ); } // يطبع الأرقام من 0 إلى 41

على وجه التحديد، forستستدعي الحلقة دالة القيمة into_iter()، التي تُعيد مُكرِّرًا يُمرِّر بدوره العناصر إلى الحلقة. forوتستمر الحلقة (أو أي دالة تستهلك المُكرِّر) حتى next()تُعيد الدالة Noneقيمة (تُعيد التكرارات التي تُنتج عناصر Some(T)قيمةً، حيث Tيُمثِّل نوع العنصر).

تُطبّق جميع المجموعات التي توفرها المكتبة القياسية هذه IntoIteratorالسمة (أي أنها تُعرّف into_iter()الدالة). وتُطبّق المُكرِّرات نفسها هذه Iteratorالسمة، الأمر الذي يتطلب تعريف next()الدالة. علاوة على ذلك، يُزوَّد أي نوع يُطبّق هذه السمة Iteratorتلقائيًا بتنفيذ IntoIteratorيُعيد نفسه.

تدعم المكررات محولات متنوعة ( ،،،، map()إلخ filter(). ) كطرق يتم توفيرها تلقائيًا بواسطة السمة.skip()take()Iterator

يمكن للمستخدمين إنشاء مُكرِّرات مُخصَّصة عن طريق إنشاء نوع يُطبِّق Iteratorالسمة. يمكن للمجموعات المُخصَّصة تطبيق IntoIteratorالسمة وإرجاع نوع مُكرِّر مُرتبط بعناصرها، مما يُتيح استخدامها مُباشرةً في forالحلقات. فيما يلي، Fibonacciيُطبِّق النوع مُكرِّرًا مُخصَّصًا غير محدود:

struct Fibonacci ( u64 , u64 );impl Fibonacci { pub fn new () -> Self { Self ( 0 , 1 ) } }impl Iterator for Fibonacci { type Item = u64 ;fn next ( & mut self ) - > Option < Self :: Item > { let next = self.0 ; self.0 = self.1 ; self.1 = self.0 + next ;​​​​​​​​​بعض ( التالي ) } }fn main () { let fib = Fibonacci :: new (); for n in fib . skip ( 1 ). step_by ( 2 ). take ( 4 ) { println! ( "{n}" ); } // يطبع 1، 2، 5، و13 }