يسمح لنا استخدام حلقات التكرار في برمجة الحاسوب بأتمتة وتكرار المهام المتشابهة مرات عدة ريثما يتحقق شرط معيّن أو ظهور حدث محدد، فتخيل إذا كان لديك قائمة بالملفات التي تحتاج إلى معالجتها أو إذا كنت تريد حساب عدد الأسطر في المقالة أو إدخال 10 أعداد أو أسماء من المُستخدِم، فيمكنك استخدام حلقة في التعليمات البرمجية الخاصة بك لحل هذه الأنواع من المشاكل.
سنشرح في هذا المقال كيفية استخدام حلقة for
في لغة جو، وهي الحلقة الوحيدة المتوفرة فيها على عكس اللغات الأخرى التي تتضمن عدة أنواع من الحلقات مثل حلقة while
أو do
، فالهدف من وجود نوع حلقة واحدة هو التبسيط وتجنب الارتباك بين المبرمجين من الأنواع المختلفة، إذ نكتفي بواحدة فقط بدلًا من وجود عدة أنواع للحلقات تحقق الغرض نفسه وبالتكلفة نفسها.
تؤدي حلقة for
إلى تكرار تنفيذ جزء من الشيفرات بناءً على عدّاد أو على متغير، وهذا يعني أنّ حلقات for
تستعمل عندما يكون عدد مرات تنفيذ حلقة التكرار معلومًا قبل الدخول في الحلقة، لكن في حقيقة الأمر يمكنك استخدامها حتى إذا لم يكن عدد التكرارات معلومًا من خلال استخدام تعليمة break
كما سترى لاحقًا.
سنبدأ بالحديث في هذا المقال عن الأنواع المختلفة من هذه الحلقة ثم كيفية التكرار على أنواع البيانات التسلسلية مثل البيانات النصية Strings ثم الحلقات المتداخلة.
التصريح عن حلقة For
حددت لغة جو 3 طرق مختلفة لإنشاء الحلقات كُلٌّ منها بخصائص مختلفة بوضع كل حالات الاستخدام الممكنة للحلقات في الحسبان، وهي إنشاء حلقة for مع شرط Condition أو ForClause أو RangeClause، إذ سنشرح في هذا القسم كيفية تصريح واستخدام أنواع ForClause و Condition، لذا دعونا نلقي نظرةً على كيفية استخدام حلقة for
مع ForClause أولًا.
تُعرّف حلقة ForClause من خلال كتابة تعليمة التهيئة initial statement متبوعة بشرط Condition متبوعة بتعليمة التقدّم Post Statement:
for [ Initial Statement ] ; [ Condition ] ; [ Post Statement ] { [Action] }
لكي نفهم المكونات السابق سنرى المثال التالي الذي يعرض حلقة for
تتزايد ضمن نطاق محدد من القيم باستخدام التعريف السابق:
for i := 0; i < 5; i++ { fmt.Println(i) }
يتمثل الجزء الأول من الحلقة في تعليمة التهيئة i := 0
والتي تعبر عن تصريح متغير اسمه i
يُسمى متغير الحلقة وقيمته الأولية هي 0؛ أما الجزء الثاني فهو الشرط i < 5
والذي يُمثّل الشرط الذي يجب أن يتحقق لكي ندخل في الحلقة أو في التكرار التالي من الحلقة، إذ يمكن القول ادخُل في الحلقة ونفّذ محتواها طالما أنّ قيمة i
أصغر من 5، والجزء الأخير هو تعليمة التقدّم ++i
والتي تشير إلى التعديل الذي سنجريه على متغير الحلقة i
بعد انتهاء كل تكرار، إذ يكون التعديل هنا هو زيادته بمقدار واحد.
سيكون خرج البرنامج كما يلي:
0 1 2 3 4
تتكرر الحلقة 5 مرات، بدايةً تكون قيمة i
تساوي 0 وهي أصغر من 5، لذا ندخل في الحلقة وننفّذ محتواها (fmt.Println(i
ثم نزيد قيمة متغير الحلقة بواحد فتصبح قيمته 1 وهي أصغر من 5، ثم ننفّذ محتوى الحلقة مرةً أخرى ونزيدها بواحد فتصبح 2 وهي أصغر من 5 وهكذا إلى أن تصبح قيمة متغير الحلقة 5 فينتهي تنفيذ الحلقة.
ملاحظة: تبدأ الفهرسة بالقيمة 0، لذا ستكون قيمة i
في المرة الخامسة للتنفيذ هي 4 وليس 5.
طبعًا ليس بالضرورة أن تبدأ بقيمة محددة مثل الصفر أو تنتهي بقيمة محددة وإنما يمكنك تحديد أي نطاق تريده كما في هذا المثال:
for i := 20; i < 25; i++ { fmt.Println(i) }
سنبدأ هنا بالقيمة الأولية 20 وننتهي عند الوصول إلى القيمة 25 بحيث تكون أقل تمامًا من 25، أي ننتهي بالعدد 24:
20 21 22 23 24
يمكنك أيضًا التحكم بخطوات الحلقة على عداد الحلقة كما تريد، إذ يمكنك مثلًا تقديم قيمة المتغير بثلاثة بعد كل تكرار كما في المثال التالي:
for i := 0; i < 15; i += 3 { fmt.Println(i) }
نبدأ هنا بالعدد 0 وننتهي عند الوصول إلى 15، وبعد كل تكرار نزيد العدّاد (متغير الحلقة) بثلاثة، وسيكون الخرج كما يلي:
0 3 6 9 12
يمكننا أيضًا التكرار بصورة عكسية، أي البدء بقيمة كبيرة والعودة خلفًا، إذ سنبدأ في المثال التالي بالعدد 100 وننتهي عند الوصول إلى 0، وهنا لابد من أن يكون التقدم عكسيًا، أي باستخدام عملية الطرح وليس الجمع:
for i := 100; i > 0; i -= 10 { fmt.Println(i) }
وضعنا هنا القيمة الأولية على 100 ووضعنا شرطًا للتوقف i < 0
عند الصفر وجعلنا التقدم عكسيًا بمقدار 10 إلى الخلف بحيث سينقص 10 من قيمة متغير الحلقة بعد كل تكرار، وبالتالي سيكون الخرج كما يلي:
100 90 80 70 60 50 40 30 20 10
يمكنك أيضًا الاستغناء عن كتابة القيمة الأولية للمتغير وعن مقدار التقدّم وترك الشرط فقط، إذ نسمي هذا النوع من الحلقات بحلقة الشرط Condition loop والتي تكافئ الحلقة while في لغات البرمجة الأخرى:
i := 0 for i < 5 { fmt.Println(i) i++ }
صرّحنا هنا عن المتغير i
قبل الدخول إلى الحلقة، إذ يُنفّذ ما بداخل الحلقة طالما أنّ الشرط محقق، أي i
أصغر من 5، ولاحظ أيضًا أننا نزيد من قيمة المتغير i
في نهاية الكتلة البرمجية الخاصة بالحلقة، فذا لم نزده، فسندخل في حلقة لانهائية، وفي الواقع نحن لم نستغنِ عن تعليمة التهيئة أو التقدّم (الخطوات)، وإنما عرّفناهم بطريقة مختلفة، والغاية من هذا التعريف هو المطابقة مع حلقة while المستخدَمة في باقي اللغات.
ذكرنا التعليمة break
في بداية المقال والتي سنستخدِمها عندما يكون شرط التوقف غير مرتبط بعدد محدد من التكرارات وإنما بحدث ما مثل تكرار عملية إدخال كلمة المرور من المستخدِم طالما ليست صحيحةً، ويمكن التعبير عن هكذا حلقة من خلال كتابة for
فقط كما يلي:
for { if someCondition { break } // do action here }
مثال آخر على ذلك عندما نقرأ من بنية غير محددة الحجم مثل المخزِّن المؤقت buffer ولا نعرف متى سننتهي من القراءة:
package main import ( "bytes" "fmt" "io" ) func main() { buf := bytes.NewBufferString("one\ntwo\nthree\nfour\n") for { line, err := buf.ReadString('\n') if err != nil { if err == io.EOF { fmt.Print(line) break } fmt.Println(err) break } fmt.Print(line) } }
يُصرّح في السطر ("buf :=bytes.NewBufferString("one\ntwo\nthree\nfour\n
عن مخزِّن مؤقت مع بعض البيانات، ونظرًا لأننا لا نعرف متى سينتهي المخزِّن المؤقت من القراءة، سننشئ حلقة for
بدون أيّ بند، أي بدون شرط أو قيمة أولية أو مقدار تقدّم.
نستخدِم داخل الحلقة ('line, err := buf.ReadString('\n
لقراءة سطر من المخزِّن المؤقت والتحقق مما إذا كان هناك خطأ في القراءة منه، فإذا كان هناك خطأ، فسنعالج الخطأ ونستخدِم الكلمة المفتاحية break
للخروج من حلقة for
، فكما نلاحظ أننا من خلال تعليمة break
لم نعُد بحاجة إلى كتابة بند الشرط لإيقافها.
تعلمنا في هذا المثال كيفية التصريح عن حلقة ForClause وكيفية استخدامها للتكرار على مجال محدد من القيم، كما تعلمنا أيضًا كيفية استخدام حلقة الشرط للتكرار حتى يتحقق شرط معيّن.
التكرار على أنواع البيانات المتسلسلة باستخدام RangeClause
من الشائع في جو استخدام الحلقات للتكرار على عناصر أنواع البيانات المتسلسلة أو التجميعية مثل الشرائح والمصفوفات والسلاسل النصية، ولتسهيل هذه العملية يمكننا استخدام حلقة for
مع بنية RangeClause، ويمكنك عمومًا استخدام بنية ForClause للتكرار على أيّ نوع من البيانات بطرق محددة طبعًا، إلا أن بنية RangeClause تُعَدّ مُنظّمَةً أكثر وأسهل في القراءة.
بدايةً سنلقي نظرةً على كيفية التكرار باستخدام ForClause في هكذا حالات:
package main import "fmt" func main() { sharks := []string{"hammerhead", "great white", "dogfish", "frilled", "bullhead", "requiem"} for i := 0; i < len(sharks); i++ { fmt.Println(sharks[i]) } }
بتشغيل الشيفرة السابقة سنحصل على الخرج التالي:
hammerhead great white dogfish frilled bullhead requiem
سنستخدِم الآن بنية RangeClause لتنفيذ الإجراءات نفسها:
package main import "fmt" func main() { sharks := []string{"hammerhead", "great white", "dogfish", "frilled", "bullhead", "requiem"} for i, shark := range sharks { fmt.Println(i, shark) } }
سيُطبع في هذه الحالة كل عنصر في القائمة. هنا استخدمنا المتغيرين i
و shark
من أجل عملية التكرار ويمكنك استخدام أيّ اسم آخر لهذه المتغيرات، إذ تعيد الكلمة المفتاحية range
قيمتين؛ الأولى هي فهرس العنصر والثانية هي قيمته، وبالتالي سيكون الخرج كما يلي:
0 hammerhead 1 great white 2 dogfish 3 frilled 4 bullhead 5 requiem
قد لا نكون بحاجة إلى عرض فهرس العنصر في بعض الأحيان، لكن إذا حذفناها، فسنتلقى خطأً في وقت التصريف:
package main import "fmt" func main() { sharks := []string{"hammerhead", "great white", "dogfish", "frilled", "bullhead", "requiem"} for i, shark := range sharks { fmt.Println(shark) } }
سيكون الخرج كما يلي:
src/range-error.go:8:6: i declared and not used
نظرًا لأنّ i
قد صُرِّح عنه في الحلقة for
، ولكن لم يُستخدم مطلقًا، فسوف يُعطي المُصرّف خطأً يُشير إلى أن هناك متغيرًا قد صُرّح عنه ولم يُستخدَم، وهذا الخطأ ستتلقاه في جو في أيّ وقت تُصرّح فيه عن متغير ولا تستخدِمه، ولحل هذه المشكلة سنستخدِم المتغير المجهول الذي يُعبَّر عنه بالشرطة السفلية _
والذي يشير إلى أنّ هناك قيمة ستُعاد ونعرف ذلك لكن لا نريدها، لذا سنستبدل المتغير i
بالمتغير المجهول وسينجح الأمر:
package main import "fmt" func main() { sharks := []string{"hammerhead", "great white", "dogfish", "frilled", "bullhead", "requiem"} for _, shark := range sharks { fmt.Println(shark) } }
سيكون الخرج كما يلي:
hammerhead great white dogfish frilled bullhead requiem
يوضِّح الخرج أنّ حلقة for
قد تكررت على شريحة السلاسل وطُبع كل عنصر من الشريحة بدون الفهرس.
يمكنك أيضًا استخدام الكلمة range
لإضافة عناصر إلى قائمة ما:
package main import "fmt" func main() { sharks := []string{"hammerhead", "great white", "dogfish", "frilled", "bullhead", "requiem"} for range sharks { sharks = append(sharks, "shark") } fmt.Printf("%q\n", sharks) }
سيكون الخرج كما يلي:
['hammerhead', 'great white', 'dogfish', 'frilled', 'bullhead', 'requiem', 'shark', 'shark', 'shark', 'shark', 'shark', 'shark']
أضفنا هنا السلسة 'shark' إلى الشريحة sharks
عدة مرات من خلال التكرار عليها، أي أضفنا إليها x مرة، بحيث تكون x هي طول القائمة التي نُكرر عليها، ولاحظ هنا أننا لسنا بحاجة إلى استخدام المتغير المجهول _
إطلاقًا، وذلك لأن هكذا حالة مُعرّفة ضمن جو، كما أننا لم نستخدِم أيّ متغير.
يمكننا أيضًا استخدام العامِل range
لملء قيم الشريحة كما يلي:
package main import "fmt" func main() { integers := make([]int, 10) fmt.Println(integers) for i := range integers { integers[i] = i } fmt.Println(integers) }
نُصرِّح هنا عن الشريحة integers
على أنها شريحة من الأعداد الصحيحة int
ونحجز مساحةً لعشرة عناصر مُسبقًا ثم نطبع الشريحة ثم نملأ هذه الشريحة بقيم عناصر فهارسها، ثم نطبعها من جديد:
[0 0 0 0 0 0 0 0 0 0] [0 1 2 3 4 5 6 7 8 9]
نلاحظ أنه في المرة الأولى للطباعة تكون عناصر الشريحة صفرية، ﻷننا حجزنا 10 عناصر ولم نُعطهم قيمًا، أي القيمة الافتراضية هي 0، لكن في المرة التالية تكون قيم الشريحة من 0 إلى 9 وهذا يُكافئ قيم الفهارس لها.
يمكننا أيضًا استخدام العامِل range
للتكرار على محارف سلسلة:
package main import "fmt" func main() { sammy := "Sammy" for _, letter := range sammy { fmt.Printf("%c\n", letter) } }
سيكون الخرج كما يلي:
S a m m y
عند استخدام range
للتكرار على عناصر رابطة map، فستُعاد قيمة كل من المفتاح والقيمة:
package main import "fmt" func main() { sammyShark := map[string]string{"name": "Sammy", "animal": "shark", "color": "blue", "location": "ocean"} for key, value := range sammyShark { fmt.Println(key + ": " + value) } }
سيكون الخرج كما يلي:
color: blue location: ocean name: Sammy animal: shark
ملاحظة: عناصر الرابطة غير مُرتبة، وبالتالي ستُطبع عناصرها بترتيب عشوائي في كل مرة تُنفّذ فيها الشيفرة.
الآن بعد أن تعرّفنا على كيفية التكرار على العناصر المتسلسة، سنتعلم كيفية استخدام الحلقات المتداخلة.
الحلقات المتداخلة Nested Loops
يمكن لحلقات التكرار في جو أن تداخل كما هو الحال في بقية لغات البرمجة، فحلقة التكرار المتداخلة هي الحلقة الموجودة ضمن حلقة تكرار أخرى وهذا مفيد لتكرار عدة عمليات على كل عنصر مثلًا وهي شبيهة بتعليمات if المتداخلة، وتُبنى حلقات التكرار المتداخلة كما يلي:
for { [Action] for { [Action] } }
يبدأ البرنامج بتنفيذ حلقة التكرار الخارجية ويُنفَّذ أول تكرار فيها والذي سيؤدي إلى الدخول إلى حلقة التكرار الداخلية، مما يؤدي إلى تنفيذها إلى أن تنتهي تمامًا، بعد ذلك سيعود تنفيذ البرنامج إلى بداية حلقة التكرار الخارجية، ويبدأ بتنفيذ التكرار الثاني ثم سيصل التنفيذ إلى حلقة التكرار الداخلية، وستُنفَّذ حلقة التكرار الداخلية بالكامل، ثم سيعود التنفيذ إلى بداية حلقة التكرار الخارجية، وهكذا إلى أن ينتهي تنفيذ حلقة التكرار الخارجية أو إيقاف حلقة التكرار عبر استخدام break أو غيرها من التعليمات.
لنُنشِئ مثالًا يستعمل حلقة for
متداخلة لكي نفهم كيف تعمل بدقة، حيث ستمر حلقة التكرار الخارجية في المثال الآتي على شريحة من الأعداد اسمها numList
؛ أما حلقة التكرار الداخلية فستمر على شريحة من السلاسل النصية اسمها alphaList
:
package main import "fmt" func main() { numList := []int{1, 2, 3} alphaList := []string{"a", "b", "c"} for _, i := range numList { fmt.Println(i) for _, letter := range alphaList { fmt.Println(letter) } } }
سيظهر الناتج التالي عند تشغيل البرنامج:
1 a b c 2 a b c 3 a b c
يُظهِر الناتج السابق أنَّ البرنامج قد أكمل أول تكرار على عناصر حلقة التكرار الخارجية بطباعة العدد، ومن ثم بدأ بتنفيذ حلقة التكرار الداخلية، لذا طبع المحارف a و b و c على التوالي، وبعد انتهاء تنفيذ حلقة التكرار الداخلية، عاد البرنامج إلى بداية حلقة التكرار الخارجية طابعًا العدد 2، ثم بدأ تنفيذ حلقة التكرار الداخلية، مما يؤدي إلى إظهار a و b و c مجددًا وهكذا.
يمكن الاستفادة من حلقات for
المتداخلة عند المرور على عناصر شريحة تتألف من شرائح، فإذا استعملنا حلقة تكرار وحيدة لعرض عناصر شريحة تتألف من عناصر تحتوي على شرائح، فستُعرَض قيم الشرائح الداخلية على أساس عنصر:
package main import "fmt" func main() { ints := [][]int{ []int{0, 1, 2}, []int{-1, -2, -3}, []int{9, 8, 7}, } for _, i := range ints { fmt.Println(i) } }
سيكون الخرج كما يلي:
[0 1 2] [-1 -2 -3] [9 8 7]
إذا أردنا الوصول إلى العناصر الموجودة في الشرائح الداخلية، فيمكننا استعمال حلقة for
متداخلة:
package main import "fmt" func main() { ints := [][]int{ []int{0, 1, 2}, []int{-1, -2, -3}, []int{9, 8, 7}, } for _, i := range ints { for _, j := range i { fmt.Println(j) } } }
سيكون الخرج كما يلي:
0 1 2 -1 -2 -3 9 8 7
نستطيع الاستفادة من حلقات for
المتداخلة عندما نريد التكرار على عناصر قابلة للتكرار داخل الشرائح.
استخدام تعليمات continue و break
تسمح لك حلقة for
بأتمتة وتكرار المهام بطريقة فعّالة، لكن في بعض الأحيان قد يتدخل عامل خارجي في طريقة تشغيل برنامجك، وعندما يحدث ذلك، فربما تريد من برنامجك الخروج تمامًا من حلقة التكرار أو تجاوز جزء من الحلقة قبل إكمال تنفيذها أو تجاهل هذا العامِل الخارجي تمامًا، لذا يمكنك فعل ما سبق باستخدام تعابير break
و continue
.
تعليمة break
توفِّر لك تعليمة break
-والتي تعاملنا معها سابقًا- القدرة على الخروج من حلقة التكرار عند حدوث عامل خارجي، وتوضَع عادةً ضمن تعبير if
، وفيما يلي أحد الأمثلة الذي يستعمل تعليمة break
داخل حلقة for
:
package main import "fmt" func main() { for i := 0; i < 10; i++ { if i == 5 { fmt.Println("Breaking out of loop") break // break here } fmt.Println("The value of i is", i) } fmt.Println("Exiting program") }
بنينا حلقة تكرار for
التي تعمل طالما كانت قيمة المتغير i
أصغر من 10 وحددنا التقدّم بمقدار 1 بعد كل تكرار، ثم لدينا تعليمة if
التي تختبر فيما إذا كان المتغير i
مساوٍ للعدد 5، فعند حدوث ذلك، فستُنفَّذ break
للخروج من الحلقة.
توجد داخل حلقة التكرار الدالة fmt.Println()
التي تُنفَّذ في كل تكرار وتطبع قيمة المتغير i
إلى أن نخرج من الحلقة عبر break
وهنا يكون لدينا تعليمة طباعة أخرى تطبع Breaking out of loop، ولكي نتأكد أننا خرجنا من الحلقة تركنا تعليمة طباعة أخرى تطبع Exiting program، وبالتالي سيكون الخرج كما يلي:
The value of i is 0 The value of i is 1 The value of i is 2 The value of i is 3 The value of i is 4 Breaking out of loop Exiting program
يُظهر الناتج السابق أنَّه بمجرد أن أصبحت قيمة المتغير i
مساويةً للعدد 5، فسينتهي تنفيذ حلقة التكرار عبر break
.
تعليمة continue
تعليمة continue
تسمح لنا بتخطي جزء من حلقة التكرار عند حدوث عامِل خارجي مع إكمال بقية الحلقة إلى نهايتها، أي سينتقل تنفيذ البرنامج إلى أوّل حلقة التكرار عند تنفيذ continue
، وتوضَع عادةً ضمن تعليمة if
.
سنستخدِم البرنامج نفسه الذي استعملناه لشرح التعبير break
أعلاه، لكننا سنستخدم التعبير continue
بدلًا من break
:
package main import "fmt" func main() { for i := 0; i < 10; i++ { if i == 5 { fmt.Println("Continuing loop") continue // break here } fmt.Println("The value of i is", i) } fmt.Println("Exiting program") }
الفرق الوحيد عن الشيفرة السابقة هي أننا استبدلنا break
بتعليمة continue
، وبالتالي لن يتوقف البرنامج عند وصول متغير الحلقة إلى 5، وإنما فقط سيتخطاها ويتابع التنفيذ، وبالتالي سيكون الخرج كما يلي:
The value of i is 0 The value of i is 1 The value of i is 2 The value of i is 3 The value of i is 4 Continuing loop The value of i is 6 The value of i is 7 The value of i is 8 The value of i is 9 Exiting program
نلاحظ أنَّ السطر الذي يجب أن يحتوي على The value of i is 5
ليس موجودًا في المخرجات، لكن سيُكمَل تنفيذ حلقة التكرار بعد هذه المرحلة مما يؤدي إلى طباعة الأعداد من 6 إلى 10 قبل إنهاء تنفيذ الحلقة.
يمكنك استخدام التعليمة continue
لتفادي استخدام تعابير شرطية معقدة ومتداخلة أو لتحسين أداء البرنامج عن طريق تجاهل الحالات التي ستُرفَض نتائجها، وبالتالي ستؤدي تعليمة continue
إلى جعل البرنامج يتجاهل تنفيذ حلقة التكرار عند تحقيق شرط معيّن، لكن بعد ذلك سيُكمِل تنفيذ الحلقة مثل العادة.
تعليمة break مع الحلقات المتداخلة
من المهم أن تتذكر أنّ تعليمة break
ستوقف فقط تنفيذ الحلقة الداخلية التي يتم استدعاؤها فيها، فإذا كان لديك مجموعة متداخلة من الحلقات، فستحتاج إلى تعليمة break
لكل حلقة:
package main import "fmt" func main() { for outer := 0; outer < 5; outer++ { if outer == 3 { fmt.Println("Breaking out of outer loop") break // break تعليمة } fmt.Println("The value of outer is", outer) for inner := 0; inner < 5; inner++ { if inner == 2 { fmt.Println("Breaking out of inner loop") break // break تعليمة } fmt.Println("The value of inner is", inner) } } fmt.Println("Exiting program") }
تتكرر الحلقتان 5 مرات ولكل منهما تعليمة if
مع تعليمة break
، فالحلقة الخارجية سوف تنكسر أو تُنهى -أي يُطبّق عليها break
- إذا كانت قيمة المتغير outer
تساوي 3؛ أما الحلقة الداخلية فستنكسر إذا كانت قيمة المتغير inner
تساوي 2، وبالتالي سيكون الخرج كما يلي:
The value of outer is 0 The value of inner is 0 The value of inner is 1 Breaking out of inner loop The value of outer is 1 The value of inner is 0 The value of inner is 1 Breaking out of inner loop The value of outer is 2 The value of inner is 0 The value of inner is 1 Breaking out of inner loop Breaking out of outer loop Exiting program
لاحظ أنه في كل مرة تنكسر فيها الحلقة الداخلية، فإن الحلقة الخارجية لا تنكسر لأن تعليمة break
ستكسِر فقط تنفيذ الحلقة الداخلية التي استُدعيَت منها.
الخاتمة
رأينا في هذا المقال كيف تعمل حلقة التكرار for
في لغة جو وكيف نستطيع إنشاءها واستعمالها، حيث تستمر حلقة for بتنفيذ مجموعة من الشيفرات لعدد محدد من المرات، كما تعرّفنا أيضًا على ثلاثة أنواع مختلفة من هذه الحلقة وكيفية استخدام كل منها، وتعلمنا أيضًا كيفية استخدام تعليمتَي continue
و break
للتحكم باستخدام حلقة for بفاعلية أكبر.
ترجمة -وبتصرُّف- للمقالَين How To Construct For Loops in Go و Using Break and Continue Statements When Working with Loops in Go لصاحبه Gopher Guides.
أفضل التعليقات
لا توجد أية تعليقات بعد
انضم إلى النقاش
يمكنك أن تنشر الآن وتسجل لاحقًا. إذا كان لديك حساب، فسجل الدخول الآن لتنشر باسم حسابك.