العبارات الشرطية

الثالث        العبارات الشرطية

 

 

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

 

العبارات المنطقية

دعنا نتذكر العبارات المنطقية في C #. يتم استخدامها غالباً لبناء تعبيرات منطقية .. العبارات المنطقية هي:

 &&   ،   ||  ،  !  ,  ^

وسنتطرق لشرح كل واحدة منها بالتفصيل ..

 

 

العبارات المنطقية & & و ||  ,

- && تعني "و"

- || تعني "او"

وتستخدمان في القيم المنطقية  (قيم bool type). من أجل النتيجة

- لمقارنة تعبيرين مع عامل التشغيل && - ليكون صحيحاً (صواباً) ، يجب أن يكون لكل المعاملات قيمة صحيحة. على سبيل المثال:

 

 

هذا التعبير هو "true" ، لأن كلا المعاملات: (2 <3) و (3 <4) هي "true". يطلق على المشغل المنطقي && أيضًا بالدائرة القصيرة ، لأنه لا يفقد الوقت في الحسابات الإضافية غير الضرورية. يقوم بتقييم الجزء الأيسر من التعبير (المعامل الأول) وإذا كانت النتيجة خاطئة ، فإنه لا يفقد الوقت لتقييم المعامل الثاني - لا يمكن أن تكون النتيجة النهائية "true" عندما لا يكون المعامل الأول "صحيحًا" ". لهذا السبب يطلق عليه أيضًا اسم المشغل المنطقي ذي الدائرة القصيرة "&&".

 

وبالمثل ، فإن العبارة || ترجع true إذا كان على الأقل أحد المعاملين القيمة "true". مثال:

 

هذا المثال هو "true" ، لأن المعامل الأول هو "true". تمامًا مثل عامل التشغيل && ، يتم إجراء الحساب بسرعة - إذا كان المعامل الأول صحيحًا ، فلن يتم حساب الثاني مباشرة ، لأن النتيجة معروفة بالفعل. يطلق عليها أيضًا العبارة المنطقية ذات الدائرة القصيرة " || ".

 

العبارتان  ^ و!

 والمعروفتان أيضًا باسم((XOR ، ينتميان إلى مشغلي الدوائر الكاملة ، لأن كل المعاملات يتم حسابها واحدة تلو الأخرى. وتكون نتيجة تطبيق المشغل "true" إذا كان أحد المعامالت "true" ، ولكن ليس كليهما في وقت واحد. وإلا فإن النتيجة false"". هنا مثال:

 

 

فتكون النتيجة :

 

 

يتم تقييم التعبير السابق كخطأ ، لأن كلا المعاملات: (2 <3) و (4> 3) صحيحة.

 

العبارة " ! " تقوم بإرجاع قيمة معكوسة للتعبير المنطقي المرتبط بها . مثال:

 

 

 

 

 

 

 

 

 

 

 

يمكن قراءة التعبير أعلاه على أنه "معاكس لحقيقة العبارة"5 == 7 ". نتيجة هذا النمط هي True (عكس False). لاحظ أنه عندما نقوم بطباعة القيمة true ، يتم عرضها على وحدة التحكم "True" (بحرف كبير) ، ويأتي هذا "العيب" من لغة VB.NET التي تعمل أيضًا في .NET Framework.

 

النتيجة :

 

 

 

 

 

 

العبارات الشرطية "if" و "if-else"

بعد مراجعة كيفية مقارنة التعبيرات ، سنستمر بالعبارات الشرطية ، والتي ستسمح لنا بتنفيذ منطق البرمجة.

العبارات الشرطية if و if-else عبارة عن عبارات تحكم شرطي. وبسببها ، يمكن للبرنامج أن يتصرف بشكل مختلف بناءً على شرط محدد يتم التحقق منه أثناء تنفيذ العبارة.

 

اذا كان

التنسيق الرئيسي للعبارة الشرطية إذا كان "IF" كما يلي:

 

 

الشرط متحقق

If (            )    

 

 

{

 

افعل كذا وكذا

 

 

}

 

مثال:

 

لاحض اننا قمنا بتعيين قيمة لمتغير من نوع int وهي 11

واستخدما عبارة IF"" لنقارن المتغير مع عدد معين , هو 5 ف اذا كان  المتغير Stephen اكبر من ال 5   .. باستخدام لوحة التحكم اطبع العبارة Stephen Hawking

والنتيجة بالفعل :

 

 

 

العبارة الشرطية "if-else"

 في C # ، كما هو الحال في معظم لغات البرمجة ، يوجد بيان شرطي مع عبارة else: عبارة if-else. تنسيقها هو ما يلي:

 

 

 

 

اذا كان

If(                  )

 

 

الشرط متحقق

 

 

 

افعل كذا وكذا

{

 

}

 

اذا كان غير ذلك (الشرط)

else

 

 

{

 

افعل كذا وكذا

 

 

}

 

 

 

فيمكننا ان نعطي اوامر خلاف تحقق الشرط "if" مثال :

 

 

في البداية قمنا بتعيين متغيرين

-  x من نوع الاعداد الصحيحة // يحمل قيمة  11

- y من نوع الاعداد العشرية // يحمل قيمة 111.99999999

العبارة الشرطية (اذا كان المتغير y اكبر او يساوي المتغير x)

باستخدام لوحه التحكم قمنا بقرائة "Stephen Hawking"

والنتيجة :

 

ولكن ماذا لو كان الشرط غير متحقق و y لايساوي x ؟

فسيختار النضام تلقائيا تحقيق الامر التالي الذي يكون بعد الif الشرطية وتكون النتيجة المخرجة "ستيفن وليام هوكينج " Stephen William Hawking"" لان y لاتساوي x وهي ايضا ليست اكبر .. فخرجنا من تحقيق الاوامر لهذا الشرط وانتقلنا الى تحقيق الاوامر الخارجة عن الشرط ,

تسلسلات "if-else-if-else-…"

في بعض الأحيان نحتاج إلى استخدام تسلسل من الشروط  ، حيث يكون الشرط الآخر عبارة عن بنية جديدة. إذا استخدمنا الشروط المتداخلة ، فستدفع الشفرة أكثر من اليمين. هذا هو السبب في أنه في مثل هذه الحالات ، يسمح باستخدام جديد إذا كان التحقق بعد الآخر مستمرا . بل إنه يعتبر ممارسة جيدة. هنا مثال:

يقدم البرنامج في المثال سلسلة من المقارنات لمتغير للتحقق مما إذا كان أحد أحرف العلة من الأبجدية الإنجليزية. تتم المقارنة التالية فقط في حالة أن المقارنة السابقة لم تكن صحيحة. في النهاية ، إذا لم يتم استيفاء أي شرط من الشروط ، يتم تنفيذ آخر بند آخر. وبالتالي ، تكون نتيجة المثال كما يلي:

 

شروط التعيين والحالة ­­(switch-case)

في هذا القسم  سوف نغطي موضوع تعيين البيان الشرطي. حيث انه يتم استخدامه للاختيار من بين قائمة من الاحتمالات والحالات

تختار حالة switch-case أي جزء من كود البرمجة يتم تنفيذه استنادًا إلى القيمة المحسوبة والمحددة لتعبير معين (في الغالب من نوع الاعداد الصحيحة int). يكون التنسيق  لاختيار وتحديد الحالة  كما يلي:

 

 

في المثال أعلاه ، ننفذ تصنيفات متعددة باستخدام عبارات الحالة بدون فواصل بعدها. في هذه الحالة ، يتم أولاً حساب القيمة الصحيحة للمتحدد - أي 6،

 ثم تتم مقارنة هذه القيمة بكل قيمة عدد صحيح في عبارات الحالة. عندما يتم العثور على تطابق ، فإن شفرة الكود بعد تنفيذه. إذا لم يتم العثور على تطابق ، فسيتم تنفيذ الحظر الافتراضي. نتيجة المثال أعلاه كالتالي:

ولكن ماذا اردنا استخدام الفواصل بين الحالات يكون التنسيق كالاتي :

          Int  num = 12;

 

ضبط (تحديد)

Switch(num)

 

 

في حالة ما اذا كانت القيمة = 2

{

 

case 2:

Console.WriteLine("Stephen William Hawking" );

 

توقف

قم بقرائة(امر)

break;

 

 

في حالة ما اذا كانت القيمة = 12

case 12:

 

 

توقف

امر

Console.WriteLine("Stephen Hawking");

 

break;

 

ماعدا ذلك/

default:

 

 

امر

Console.WriteLine("What is your name");

 

 

توقف

break;

 

 

}

 

 

 

 

ال ( switch ) هو عبارة عن تعبير يحدد اسم المتغير الذي نريد  مقارنته واعطاء اوامر لكل حالة نحددها بالcase)) ، مثل رقم أو سلسلة. يقارن عامل التحديد نتيجة المحدد لكل قيمة مدرجة في  الحالة في هيكل بنية المفتاح في هذا المثال . إذا تم العثور على تطابق في  حالة المحددة ، يتم تنفيذ الامر المقابل للحالة (بسيط أو معقد ). إذا لم يتم العثور على تطابق لكل الحالات  ، فسيتم تنفيذ العبارة الافتراضية default والتي تعني ماعدا ذلك (عندما يكون موجودًا) فمن غير المشترط ان تكتبه لتكون سلسلة الحالات فعالة . وينتقل التنفيذ إلى  الحالة التالية  ويستمر حتى يجد عامل تشغيل break. بعد كسر الهيكل الافتراضي الالزامي.                         - ليس من الضروري أن تكون العبارة default هي الأخيرة ، ولكن يُنصح بوضعها في النهاية ، وليس في منتصف سلسلة الحالات                               - يجب أن يتم حساب القيمة المحددة قبل مقارنتها بالقيم الموجودة داخل الحالة الشرطية .                                                                                 - يجب ألا تحتوي التصنيفات على قيم مكررة ، يجب أن تكون فريدة.                                                                   كما يمكن رؤيته في المثال أعلاه ، تنتهي كل حالة ب : ، الذي ينهي قيمة البنية . يتطلب المحول البرمجي في  C # فاصل الكلمة في نهاية كل قسم حالة يحتوي على تعليمات برمجية.                                                                          -إذا لم يتم العثور على الكود بعد بيان الحالة ، فيمكن حذف الفاصل

 

 

 

 

  Conditions Loops   الشروط الحلقية  :-

سنقوم بفحص تركيبات البرمجة الحلقية التي يمكن من خلالها تنفيذ مقتطف شفرة بشكل متكرر. سنناقش كيفية تنفيذ التكرار المشروط (أثناء قيام الحلقات بالعمل ) وكيفية التعامل مع الحلقات. سنقدم أمثلة على الاحتمالات المختلفة لتعريف الحلقات وكيفية بناءها وبعض استخداماتها الرئيسية. أخيراً ، سنناقش بناء حلقة foreach وكيف يمكننا استخدام الحلقات المتعددة الموضوعة داخل بعضها البعض (الحلقات المتداخلة).

ما هي "الحلقة"؟

في البرمجة غالبا ما يتطلب التنفيذ المتكرر سلسلة من العمليات الشرطية . الحلقة هي بنية برمجة أساسية تسمح بالتنفيذ المتكرر لجزء من شفرة المصدر للكود. اعتمادًا على نوع الحلقة ، يتكرر الرمز الموجود فيه عددًا ثابتًا من المرات أو يتكرر حتى يصبح الشرط معينًا صحيحًا (موجودا).                              الحلقات التي لا تنتهي أبدا تسمى حلقات لانهائية. نادراً ما نحتاج إلى استخدام حلقة لا نهائية إلا في الحالات التي يتم فيها استخدام أي مكان في الجسم للحلقة لإنهاء تنفيذها قبل الأوان. سنغطي هذا في وقت لاحق ولكن الآن دعونا ننظر في كيفية إنشاء حلقة في لغة C #.

انواع الشروط الحلقية :-

-  while loop

- do-while loop

-loop for

While loopحلقة "طالما"  

واحدة من أبسط الحلقات واكثرها شيوعا وتنسيقها كالاتي :

 

 

 

طالما ان المتغير اكبر من 3  اقرأ "الخمسة اكبر من الثلاثة"

ملاحضة ان اي نوع من المحررات تعمل فيه سيتوقف فجأة او سيتأخر قليلا قبل ان يقرأ النتيجة

 

تلخيص الأرقام من 1 إلى N

 في هذا المثال ، سنفحص كيفية استخدام حلقة while في العثور على مجموع الأرقام من 1 إلى n. حيث تتم قراءة الرقم n من وحدة التحكم:

أولاً ، نقوم بتهيئة المتغيرات num و sum بقيمة 1. في num ، نحتفظ بالرقم الحالي ، الذي نضيفه إلى مجموع الأرقام السابقة. من خلال كل حلقة نزيد عدد الأسطوانات مع 1 للحصول على العدد التالي ، ثم في حالة الحلقة ، نتحقق مما إذا كانت في النطاق من 1 إلى n. يحتوي متغير المجموع على مجموع الأرقام من 1 إلى عدد( في أي وقت). عند دخول الحلقةwhile  ، نضيف مجموع الرقم المخزن في num. نطبع على وحدة التحكم جميع الأرقام بالأرقام من 1 إلى n بفاصل "+" والنتيجة النهائية للتلخيص بعد نهاية الحلقة. تكون نتيجة تنفيذ البرنامج كما يلي :

N =

ندخل 17

النتيجة :

The sum 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 = 153

دعنا نعطي مثالا آخر على استخدام الحلقة while ، قبل الانتقال إلى تنسيقات أخرى لتنظيم الحلقات.

 

 

 

نستخدم مقسم المتغير divider قيمة مقسوم محتمل للرقم. أولاً ،                   نقوم بتهيئته بـ 2 (أصغر مقسم ممكن). المتغير maxDivider هو أقصى قاسم ممكن ، والذي يساوي الجذر التربيعي للرقم. إذا كان لدينا قاسم مقسوم أكبر من √num ، فحينئذٍ يجب أن يكون num أيضًا قاسمًا آخرًا أصغر من √num وهذا هو السبب في أنه من غير المجدي التحقق من الأرقام الأكبر من √num. بهذه الطريقة نخفض عدد مرات تكرار الحلقة. بالنسبة للنتيجة (للتبسيط)، نستخدم متغيرًا منطقيًا يسمى prim. في البداية ، قيمته true. أثناء المرور عبر الحلقة while ، إذا تبين أن الرقم له قاسم ، فإن قيمة prime ستصبح false. وتتكون حالة الحلقة أثناءها من شرطين فرعيين آخرين مرتبطين بالمشغل المنطقي . من أجل تنفيذ الحلقة ، يجب أن يكون هذان الشرطان الفرعيين صحيحين في وقت واحد. إذا وجدنا في مرحلة ما قاسمًا  ، يصبح رأس المتغير false ولم تعد الحالة صحيحة. وهذا يعني أنه يتم تنفيذ الحلقة حتى يجد القاسم الأول للرقم أو حتى يثبت أن num غير قابل للقسمة بأي من الأرقام في النطاق من 2 إلى √num.

 

إليك كيفية ظهور نتيجة تنفيذ المثال أعلاه إذا كانت قيم الإدخال هي الأرقام 37 و 34 على التوالي:

Enter a positive number: 37

      Prime? True

Enter a positive number: 34

Prime? False

Do - While  حلقة :-

 

افعل

تتشابه حلقة do-while مع حلقة while ، ولكنها تتحقق من الشرط بعد كل تنفيذ للشرط الدائري. يسمى هذا النوع من الحلقات الحلقات مع الشرط في النهاية (حلقة ما بعد الاختبار). تنسيق حلقة do-while بالشكل التالي:

 

do

 

الامر

 {

 

}

 

طالما

While (          );

 

 

الشرط متحقق

 

 

 

 

في البداية يتم تنفيذ الجسم حلقة. ثم يتم فحص حالته. إذا كان صحيحًا ، يتكرر جسم الحلقة ، وإلا تنتهي الحلقة. يتكرر هذا المنطق حتى يتم كسر حالة الحلقة. يتم تنفيذ نص الحلقة مرة واحدة على الأقل. إذا كان شرط الحلقة دائمًا صحيحًا ، فلن تنتهي الحلقة أبدًا.

استخدام حلقات Do-While يتم استخدام حلقة do-while عندما نريد ضمان أن يتم تنفيذ تسلسل العمليات فيها مراراً وتكراراً مرة واحدة على الأقل في بداية الحلقة.

 

 حساب العامل التكراري في حلقة do-while

في  في هذا المثال ، سنحسب مرة أخرى العاملية لرقم معين n ، ولكن هذه المرة بدلاً من حلقة لا نهائية ، سنستخدم عملية do-while. يشبه المنطق  في المثال السابق:

 

 

في البداية نبدأ بنتيجة 1 وتتكاثر النتيجة بالتتابع عند كل تكرار بواسطة n ، وتقلل n بواسطة وحدة واحدة ، حتى يصل n إلى 0. هذا يعطينا المنتج n * (n-1) *… * 1. وأخيرًا ، نطبع النتيجة على وحدة التحكم. تقوم هذه الخوارزمية دائمًا بإجراء عملية مضاعفة واحدة على الأقل وهذا هو السبب في أنها لن تعمل بشكل صحيح عندما تكون n ≤ 0. هنا نتيجة تنفيذ المثال السابق لـ n = 7:

n = 7

 n! = 5040

 

 

 

                    الحلقة الشرطية :-For Loops

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

for (A; B; C)

{

D;

}

-----------------------------------------------------------------

for (int i=0; i<10; i++)

{

/* الامر */

}

أنها تحتوي على كتلة التهيئة (A) ، شرط (B) ، الامر(D) وتحديث أوامر للمتغيرات حلقة (C). سنشرحها بالتفصيل قريبا. قبل ذلك ، لننظر إلى كيفية ظهور رمز برنامج الحلقة for-loop:

 

يتكون من جزء (تهيئة) للعداد (في النمط int i = 0) شرط منطقي (i <10)

تعبير لتحديث العداد (i ++ ، قد يكون i-- أو على سبيل المثال ، i = i + 3) وامر الحلقة.

يميز عداد الحلقة من أنواع أخرى من الحلقات. غالبًا ما يتغير العداد من قيمة أولية معينة إلى قيمة نهائية بترتيب تصاعدي ، على سبيل المثال من 1 إلى 100. ويعرف عادة عدد التكرارات للحلقة المعينة قبل بدء تنفيذها. يمكن أن تحتوي حلقة for-loop على متغير حلقة أو عدة متغيرات تتحرك في ترتيب تصاعدي أو تنازلي أو بخطوة. فمن الممكن متغير حلقة واحدة لزيادة والآخر - لتقليل. من الممكن أيضًا إجراء حلقة من 2 إلى 1024 في خطوات الضرب بمقدار 2 ، نظرًا لأن تحديث متغيرات الحلقة لا يمكن أن يحتوي فقط على إضافة ، ولكن أي عمليات حسابية أخرى (بالإضافة إلى عمليات أخرى).

نظرًا لأن أيًا من العناصر المدرجة في الحلقات الإلزامية ليس إلزاميًا ، يمكننا تخطيها جميعًا وسوف نحصل على حلقة لا نهائية:

for ( ; ; )

 {

 // الامر

}

حساب N ^ M :-

كمثال آخر ، سنكتب برنامجًا يرفع العدد n إلى قوة m ، ولهذا الغرض ، سنستخدم حلقة for-loop:

 

 أولاً نقوم بتهيئة واعطاء قيمة  result (result = 1). تبدأ الحلقة عن طريق تحديد قيمة أولية للمتغير المقابل (int i = 0). نحدد شرط تنفيذ الحلقة (i <m). وبهذه الطريقة سيتم تنفيذ الحلقة من 0 إلى m-1 ، أي على المرات بالضبط. خلال كل تشغيل للحلقة ، نضاعف النتيجة بـ n وهكذا سوف يتم رفع n إلى القوة التالية (1 ، 2 ، ... ، m) في كل تكرار. أخيرا نطبع النتيجة لنرى ما إذا كان البرنامج يعمل بشكل صحيح. إليك كيفية ظهور نتيجة البرنامج لـ n = 2 و m = 10:

n = 2

m = 10

n^m = 1024

for loop مع العديد من المتغيرات :-

كما رأينا بالفعل ، في بناء حلقة for-loop ، يمكننا استخدام متغيرات متعددة في نفس الوقت. في ما يلي مثال يكون فيه لدينا عدادات. يتحرك أحد العدادات من 1 والآخر يتحرك لأسفل من 10:

 

 

الشرط الخاص بإنهاء الحلقة هو تراكب العدادات. أخيرا نحصل على النتيجة التالية:

 

 

 

خصائص  " continue "

continue تعني إيقاف المشغل متابعة التكرار الحالي للحلقة الداخلية ، دون إنهاء الحلقة. مع المثال التالي سنفحص كيفية استخدام هذا المشغل. سنقوم بحساب مجموع كل الأعداد الصحيحة الفردية في النطاق [1 ... n] ، والتي لا يمكن القسمة عليها 7 باستخدام حلقة for-loop: 

 

أولاً ، نقوم بتهيئة متغير الحلقة مع قيمة 1 لأن هذا هو أول عدد صحيح فردي داخل النطاق [1 ... n]. بعد كل تكرار للحلقة ، نتحقق مما إذا لم أتجاوز n (i <= n) بعد. في التعبير عن تحديث المتغير ، نزيده بمقدار 2 من أجل تمريره فقط من خلال الأرقام الفردية. داخل جسم الحلقة ، نتحقق مما إذا كان الرقم الحالي قابل للقسمة على 7. إذا كان الأمر كذلك ، فإننا نطلق على المشغل (continue) ، الذي يتخطى بقية جسم الحلقة (يتخطى إضافة الرقم الحالي إلى المجموع). إذا كان الرقم غير قابل للقسمة على سبعة ، فإنه يستمر بتحديث المبلغ بالرقم الحالي. تكون نتيجة المثال لـ n = 11 كما يلي:

حلقات "Foreach " الشرطية :-

حلقة foreach (المطورة for-loop) جديدة لعائلة C / C ++ / C # من اللغات ، ولكنها معروفة جيدًا ل VB و PHP. تعمل هذه العبارة الشرطية  على تكرار جميع عناصر مجموعة أو قائمة أو مجموعة أخرى من العناصر (IEnumerable). تمر عبر جميع عناصر المجموعة المحددة حتى إذا لم يتم فهرسة المجموعة.

سنناقش ونتعلم كيف تتكون  المصفوفات  ونعرف الكثير من التفاصيل عنها في الفصل "المصفوفات" ، ولكن في الوقت الحالي يمكننا أن نتخيل مصفوفة واحدة كتسلسل مرتب للأرقام أو عناصر أخرى(للشرح). إليك كيف تبدو حلقة foreach:

 Foreach(اكتب متغير في المجموعة )

{

الاوامر //

}

كما نرى ، فهو أبسط بكثير من الحلقة القياسية ، ولذلك يفضله المطورين في كثير من الأحيان لأنه يحفظ الكتابة عندما تحتاج إلى المرور بكل عناصر مجموعة معينة. في ما يلي مثال يوضح كيف يمكننا استخدام foreach:

 

 

 

 

 

 

في المثال ، نقوم بإنشاء مصفوفة من الأرقام ، والتي يتم بعدها مرورها بحلقة foreach ، ويتم طباعة عناصرها على وحدة التحكم. بعد ذلك يتم إنشاء مجموعة من أسماء المدن (السلاسل) بنفس الطريقة التي يتم بها إدخالها وتتم طباعة عناصرها على وحدة التحكم. نتيجة المثال هي :

الحلقات المتداخلة :-

الحلقات المتداخلة عبارة عن تراكيب برمجية تتكون من عدة حلقات موجودة في بعضها البعض. يتم تنفيذ الحلقة ألاعمق أكثر ، وأبعد -  بمرات أقل. دعنا نرى كيف تبدو الحلقتان المتداخلتان :

 

 

 

 

 

بعد تهيئة أول حلقة ، سيبدأ تنفيذ الاوامر ، والذي يحتوي على الحلقة الثانية (المتداخلة). سيتم تهيئة المتغير الخاص به ، وسيتم فحص حالته وسيتم تنفيذ الكود البرمجي داخل جسمه ، ثم يتم تحديث المتغير وسيستمر التنفيذ حتى تعود الحالة للخطأ . بعد ذلك سيستمر التكرار الثاني للحلقة الأولى ، وسيتم تحديث المتغير الخاص به وسيتم تنفيذ الحلقة الثانية بأكملها مرة أخرى. سوف يتم تنفيذ الحلقة الداخلية بالكامل عدة مرات مثل جسم الحلقة الخارجية. لناخذ مثال لكي تتضح صورة الحلقات المتداخلة بشكل افضل :

 

الأرقام الأولية في الفاصل الزمني

لننظر في مثال آخر على الحلقات المتداخلة.

 - لقد وضعنا هدفًا للطباعة على وحدة التحكم جميع الأرقام الأولية في الفاصل الزمني [n… m]. سنحدد الفاصل الزمني بواسطة for-loop وللتحقق من وجود رقم أولي سنستخدم حلقة متداخلة أثنائه :

باستخدام الحلقة الخارجية ، نتحقق من كل عدد من الأرقام n ، n + 1 ، ... ، m إذا كانت أولية. عند كل تكرار للحلقة الخارجية ، نتحقق مما إذا كان رقم متغير, المتغير هو رقم أولي. المنطق الذي تحقق من وجود رقم أولي له معروف لدينا بالفعل.

في البداية ، نبدأ في تهيئة المتغير الرئيسي مع true. باستخدام الحلقة الداخلية ، نتحقق من كل رقم [2… √num] إذا كان مقسومًا لعدد الأسطوانات وإذا كان الأمر كذلك ، فسنقوم بتعيين القيمة الأولية إلى false. بعد الانتهاء من الحلقة أثناء التكرار ، يشير  المتغير Boolean إلى ما إذا كان العدد أوليًا أم لا. إذا كان الرقم أساسيًا ، فنقوم بطباعته على وحدة التحكم. إذا قمنا بتنفيذ المثال لـ n = 3 و m = 75 ، فسوف نحصل على النتيجة التالية:

n = 3 m = 75

  3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73