كيفية بناء دوائر المرات المتكررة في Go

مقدمة

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

في Go، يوفر الدائرة for التنفيذ المتكرر مبني على عداد الدائرة أو المتغير الدائري. بخلاف اللغات البرمجية الأخرى التي تحتوي على أشكال دائرة متعددة مثل while، do وهلم جرا ، يوجد في Go دائرة for وحدها. هذا يساهم في جعل برمجياتك أكثر واضحًا وقراءة، لأنك لا تتعاقد بخطوط مختلفة لتحقيق نفس الدائرة البرمجية. هذا التحسين في القراءة وخفض محتوى التفكير خلال التطوير سيجعل برمجياتك أقل عرضة للأخطاء من أخرى اللغات.

في هذا الدرس التعليمي، ستتعلم كيف تعمل دائرة for في Go بشكل ثلاثي أحداث أساسي. سنبدأ بعرض كيفية إنشاء أنواع مختلفة من الدورات، متابعة مع النوعية التي تتبع من البيانات التسلسلية في Go. سننتهي بشرح كيفية استخدام الدورات المدمجة.

تعريف الشرطين المرشدين والدوائر الشرطية

ولكي نتوافر بشكل واسع من حالات الاستخدام، هناك ثلاثة طرق مختلفة لإنشاء دوائر الـ for في Go، كل منها بما يلزمه بواسطته. هذه هي إنشاء دورة for مع الشرط، الشرط المرشد، أو الشرط النطاق، وسنشرح في هذا الجزء كيفية تعريف واستخدام النسخ المختلفة للشرط المرشد والشرط الناجح.

دعونا ننظر إلى كيفية استخدام دوائر الـ for مع الشرط المرشد أولا.

تعريف الدورة المرشدة تعني أن لها عبارة أولية، موافقة شرط، وعبارة ما بعد التنفيذ. تتركب بالنظام السينتاكس التالي:

for [ Initial Statement ] ; [ Condition ] ; [ Post Statement ] {
    [Action]
}

لنشرح ما تفعل الأجزاء السابقة، دعونا ننظر إلى دوائر الـ for التي تزيد من خلال مجموعة معينة من القيم باستخدام نمط الشرط المرشد:

for i := 0; i < 5; i++ {
	fmt.Println(i)
}

دعونا نتجزأ هذه الدورة ونحدد كل جزء.

أول جزء من الدورة هو i := 0. هذه هي العبارة الأولية:

for i := 0; i < 5; i++ {
	fmt.Println(i)
}

هي تقول أننا ندeclare متغير يُدعى i، و نضبط قيمة البدء الى 0.

ومن ثم يوجد الشرط:

for i := 0; i < 5; i++ {
	fmt.Println(i)
}

في هذه الشرط، أعلنا أنه بينما i أقل من قيمة 5، سيستمر الدورة في الدور.

وأخيرًا يوجد العبارة الماكافأة.

for i := 0; i < 5; i++ {
	fmt.Println(i)
}

في العبارة الأخيرة، نقوم بزيادة المتغير المدور i بواحد في كل مرة يحدث تكرار باستخدام مشغل الزيادة i++ الزيادة

عند تشغيل هذا البرنامج، يبدو الناتج كالتالي:

Output
0
1
2
3
4

تشتغل الحلقة 5 مرات. في البداية، تم تعيين i إلى 0، ثم التحقق مما إذا كان i أقل من 5. نظرًا لأن قيمة i كانت أقل من 5، تم تنفيذ الحلقة وتنفيذ عملية fmt.Println(i). بعد انتهاء الحلقة، تم استدعاء العبارة الأخيرة لـ i++، وتم زيادة قيمة i بـ 1.

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

for i := 20; i < 25; i++ {
	fmt.Println(i)
}

هنا، يتم تكرار العدد من 20 (مشمولًا) إلى 25 (غير مشمولًا)، لذا يبدو الناتج كالتالي:

Output
20
21
22
23
24

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

أولاً، دعونا نستخدم عبارة أخيرة بقيم إيجابية:

for i := 0; i < 15; i += 3 {
	fmt.Println(i)
}

في هذه الحالة، تم إعداد حلقة for بحيث تتم طباعة الأرقام من 0 إلى 15، ولكن بزيادة 3، لذا يتم طباعة فقط كل ثالث رقم، مثل ما يلي:

Output
0
3
6
9
12

نستطيع أيضًا استخدام قيمة سلبية لما يتم برمجة جماليًا للمعاملة للتكرار بعكس التوالي، لكن سيتوجب علينا تنسيق معاملتنا البدئية والشروط المتعلقة بالمعاملة تمامًا:

for i := 100; i > 0; i -= 10 {
	fmt.Println(i)
}

في هذه الحالة ، نضع i في قيمة بدئية 100، نستخدم شرط i < 0 لتوقف في 0، والمعاملة البعدية تخفض قيمةها بـ10 من خلال مادة ال-= المفرد. يبدأ الدورة في 100 وتنتهي في 0، تخفض بـ10 في كل دورة. يمكننا رؤية هذا الحدث في الخروج:

Output
100
90
80
70
60
50
40
30
20
10

يمكنك أيضًا تعيين المعاملة البدئية والمعاملة البعدية خارج هياكل الfor، ومن ثم استخدم مجرد شروط. هذا ما يطلق عليه الدورة الشرطية:

i := 0
for i < 5 {
	fmt.Println(i)
	i++
}

في هذه المرة ، قمنا بتعيين المتغير i بشكل منفصل عن الدورة التي توجد في السطر السابق من البرمجيات. يتم فقط برمجة شرط واحد تفقد إذا كان i أقل من 5، وأي أن تقييم الشرط سيكون true، ستستمر الدورة في التكرار.

في بعض الأحيان قد لا يعرف عدد الدورات التي ستحتاج لإنجاز مهمة معينة. في تلك الحالة، يمكنك تعمية جميع المعاملات واستخدام كلمة المبرمجي break للخروج من التنفيذ:

for {
	if someCondition {
break
}
	// فعل عمل هنا
}

مثال على هذا قد يكون إذا كنا نقرأ من بندقية بحجم غير محدود مثل ال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("واحد\nاثنان\nثلاثة\nأربعة\n") يعلن عن محفظ بمعدل بعض البيانات. لأننا لا نعرف متى سينتهي معالجة المحفظ، فنحن نخلق دورة for بدون شرط. داخل الدورة for، نستخدم line, err := buf.ReadString('\n') لقراءة سطر من المحفظ وفحص ما إذا كان هناك خطأ في قراءة المحفظ. إذا كان هناك خطأ، نتعامل مع الخطأ، ونستخدم كلمة المرور break للخروج من الدورة. مع هذه النقاط break، لا يتوجب عليك تضمين شرط لتوقف الدورة.

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

التجول في أنواع البيانات التسلسلية بواسطة البرمجيات الشاملة

يتم بشكل شائع في جو الاستخدام للدوائر for للتجول فوق عناصر النوعات التي تتبع تسلسل أو تنوع الأنواع المجموعية مثل الأقسام، الأنامل و السطور. لجعل القيام بذلك أسهل، يمكننا استخدام دورة for مع الsyntax RangeClause. بينما يمكنك أن تدور خلال الأنواع التي تتبع تسلسل بواسطة الsyntax ForClause، فإن الRangeClause أنظف وأسهل القراءة.

قبل أن ننظر في استخدام RangeClause، دعونا ننظر في كيفية التجول خلال قطعة بواسطة syntax 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])
	}
}

سيأتي هذا بالمجموع يعطي ما يلي:

Output
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، يمكننا تسمية المتغير أي ما يكون أسم متغير سليم وسيحصل على نفس الخريطة:

Output
0 hammerhead
1 great white
2 dogfish
3 frilled
4 bullhead
5 requiem

عندما تستخدم range على قطعة، فسيعود دومًا بقيمتين. القيمة الأولى ستكون البند الذي يتم فيه تجول الدورة الحالي والثانية ستكون القيمة في ذلك البند. في هذه الحالة، للدورة الأولى، كان البند 0 وكان القيمة hammerhead.

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

package main

import "fmt"

func main() {
	sharks := []string{"hammerhead", "great white", "dogfish", "frilled", "bullhead", "requiem"}

	for i, shark := range sharks {
		fmt.Println(shark)
	}
}

Output
src/range-error.go:8:6: i declared and not used

لأن i يُعلن في الدورة البرمجية ، ولكنه لا يُستخدم أبداً ، سيستجيب المصنع بخطأ i declared and not used. هذا نفس الخطأ الذي ستحصل عليه في Go في أي وقت تعلن متغيرًا ولا تستخدمه.

وبسبب ذلك ، يوفر Go المعرفي الفارغ الذي هو التحرير (_). في دورة البرمجية، يمكنك استخدام المعرفي الفارغ لتجاهل أي قيمة تعود من كلمة المجال range. في هذه الحالة ، نريد تجاهل المربع ، المربع الأول الذي يعود.

package main

import "fmt"

func main() {
	sharks := []string{"hammerhead", "great white", "dogfish", "frilled", "bullhead", "requiem"}

	for _, shark := range sharks {
		fmt.Println(shark)
	}
}

Output
hammerhead
great white
dogfish
frilled
bullhead
requiem

هذه الخروجة تظهر أن الدورة البرمجية تتجول خلال قطعة الأحرف التي نقلت منها كل عنصر من القطعة بدون المربع.

يمكنك أيضًا استخدام 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)
}

Output
['hammerhead', 'great white', 'dogfish', 'frilled', 'bullhead', 'requiem', 'shark', 'shark', 'shark', 'shark', 'shark', 'shark']

هنا أضفنا عنصر مكون من السطر "shark" لكل عنصر من طول القطعة sharks.

لاحظ أننا لم نحتاج إلى استخدام المعرفي الفارغ _ لتجاهل أي قيمة تعود من عملية الrange المعروف. يسمح لنا Go بترك كل جزء الإعلان البرمجي لدرجة الrange إذا لم نحتاج إلى استخدام أي من القيمتين التي تعود.

يمكننا أيضًا استخدام عملية ال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 بعشرة قيم فارغة، لكن الدورة الfor الخاصة تestablece جميع القيم في القائمة بهذه الطريقة:

Output
[0 0 0 0 0 0 0 0 0 0]
[0 1 2 3 4 5 6 7 8 9]

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

يمكننا أيضًا استخدام متغير range للمتوال في تسلسل كلمة:

package main

import "fmt"

func main() {
	sammy := "Sammy"

	for _, letter := range sammy {
		fmt.Printf("%c\n", letter)
	}
}

Output
S
a
m
m
y

عندما نتجه في مقطع map، سيعيد range كل ما يتم إرجاعه هو الkey والvalue:

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)
	}
}

Output
color: blue
location: ocean
name: Sammy
animal: shark

وبعد أن تعلمنا كيفية التجول فوق البيانات التسلسلية مع range دورات for، دعونا ننظر إلى كيفية استخدام الدورات التي تحيطة بدورات.

دورات في دورات

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

تشبه الدورات المدمجة بنية شبيهة بالأعمال المدمجة للأعلانات الشرطية. وهي تنشأ بالتالي:

for {
    [Action]
    for {
        [Action]  
    }
}

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

دعونا ننفذ دورة 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)
		}
	}
}

حين تشغل هذا البرنامج، سنحصل على المخرج التالي:

Output
1
a
b
c
2
a
b
c
3
a
b
c

توليد المخروط المقدم يوضح أن البرنامج يكمل أول دورة خارجية بطريقة الطباعة 1 وهذا يتسبب في إكمال الدورة الداخلية بالطباعة للحروف a، b، c متواليًا. بما أن الدورة الداخلية تكمل بعدها، يعود البرنامج إلى أعلى الدورة الخارجية، يطبع 2 ومن ثم يطبع مجددًا الدورة الداخلية بأكملها (a، b، c)، وهكذا بأكمله.

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

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)
	}
}

Output
[0 1 2]
[-1 -2 -3]
[9 8 7]

للوصول إلى كل عنصر فريد من القوائم الداخلية، سنقوم بتنفيذ دورة منقولة داخلية:

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)
		}
	}
}

Output
0
1
2
-1
-2
-3
9
8
7

عندما نستخدم دورة منقولة داخلية هنا، يمكننا أن نتجه حول العناصر الفريدة الموجودة داخل القطع.

الخلاصة

تعلمنا في هذه الدرس كيفية تعليم واستخدام الدورات المرة الثالثة لحل المهام المتكررة في Go. وتعلمنا أيضًا ثلاث أنواع مختلفة من الدورة وأين يتم استخدامها. لتعلم المزيد عن الدورات وكيفية تحكم تدفقها قراءة Using Break and Continue Statements When Working with Loops in Go.