حلقة for في Golang: أشكالها الأربعة مع أمثلة

لدى Go كلمة حلقة واحدة بالضبط: for. لها أربعة أشكال، وتغطّي معًا كل حلقة كنت ستكتبها بـ for أو while أو do while أو foreach في لغات أخرى.

package main

import "fmt"

func main() {
	// 1. three-clause loop
	for i := 0; i < 3; i++ {
		fmt.Println("count", i)
	}

	// 2. condition only (a while loop)
	n := 20
	for n > 1 {
		n /= 2
	}
	fmt.Println("n ended at", n)

	// 3. infinite loop with break
	tries := 0
	for {
		tries++
		if tries == 4 {
			break
		}
	}
	fmt.Println("tries:", tries)

	// 4. range
	for i, fruit := range []string{"apple", "kiwi"} {
		fmt.Println(i, fruit)
	}
}

لا أقواس حول ترويسة الحلقة، والأقواس المعقوصة مطلوبة دائمًا.

الحلقة بثلاثة أجزاء

for init; condition; post {
	// body
}

1. يُنفَّذ init مرة واحدة قبل الحلقة. عادة يكون تعريف متغيّر قصيرًا مثل i := 0، وهذا المتغيّر يوجد داخل الحلقة فقط.
2. يُفحص condition قبل كل تكرار. عندما يكون خاطئًا تنتهي الحلقة.
3. يُنفَّذ الجسم.
4. يُنفَّذ post بعد كل تكرار، وعادة يكون i++.

package main

import "fmt"

func main() {
	// count down
	for i := 5; i > 0; i-- {
		fmt.Print(i, " ")
	}
	fmt.Println("liftoff")

	// step by 10
	for x := 0; x <= 50; x += 10 {
		fmt.Print(x, " ")
	}
	fmt.Println()

	// two variables at once (parallel assignment in post)
	word := []rune("racecar")
	isPalindrome := true
	for i, j := 0, len(word)-1; i < j; i, j = i+1, j-1 {
		if word[i] != word[j] {
			isPalindrome = false
			break
		}
	}
	fmt.Println("racecar is a palindrome:", isPalindrome)
}

i++ عبارة في Go لا تعبير، لذا لا يمكن أن يحتوي post على i++, j--. استخدم إسنادًا متوازيًا بدلًا من ذلك: i, j = i+1, j-1.

الأجزاء الثلاثة اختيارية. for ; i < 10; {} صالحة، ويعيد gofmt كتابتها إلى for i < 10 {}، وهو الشكل التالي.

حلقة الشرط فقط (while في Go)

مع شرط وحده تتصرّف for مثل while في اللغات الأخرى:

package main

import "fmt"

func main() {
	// Collatz sequence: how many steps to reach 1?
	n, steps := 27, 0
	for n != 1 {
		if n%2 == 0 {
			n /= 2
		} else {
			n = 3*n + 1
		}
		steps++
	}
	fmt.Println("steps:", steps)
}

لا توجد do while منفصلة. صفحة حلقة while تبيّن كيف تحصل على سلوك "التنفيذ مرة واحدة على الأقل".

الحلقات اللانهائية

for دون أي شيء بعدها تدور إلى الأبد. اخرج منها بـ break أو return أو os.Exit أو panic:

for {
	line, err := reader.ReadString('\n')
	if err != nil {
		break
	}
	process(line)
}

هذا هو الشكل المعتاد للخوادم والعمّال وحلقات الإدخال. الحلقة for {} بجسم فارغ تستهلك نواة معالج كاملة؛ في الشيفرة الحقيقية يتوقّف الجسم على شيء ما (قراءة، أو استقبال من قناة، أو select).

حلقات range

تمرّ range على مجموعة وتعطي قيمة أو قيمتين في كل تكرار. ما هما يعتمد على ما تمرّ عليه:

package main

import (
	"fmt"
	"maps"
	"slices"
)

func main() {
	nums := []int{10, 20, 30}
	for i, v := range nums {
		fmt.Printf("nums[%d] = %d\n", i, v)
	}

	// only values: discard the index with _
	sum := 0
	for _, v := range nums {
		sum += v
	}
	fmt.Println("sum:", sum)

	// only indexes: omit the second variable
	for i := range nums {
		nums[i] *= 2
	}
	fmt.Println(nums)

	// a string yields runes
	for i, r := range "héllo" {
		fmt.Print(i, ":", string(r), " ")
	}
	fmt.Println()

	// a map yields keys and values in random order, so sort the keys
	ages := map[string]int{"Ben": 25, "Ana": 31, "Chen": 28}
	for _, name := range slices.Sorted(maps.Keys(ages)) {
		fmt.Println(name, ages[name])
	}

	// an integer (Go 1.22)
	for i := range 3 {
		fmt.Print(i, " ")
	}
	fmt.Println()
}

ثلاث تفاصيل تظهرها المخرجات:

• متغيّر القيمة نسخة. v *= 2 داخل الحلقة لن يغيّر الشريحة؛ لتعديل العناصر افهرس الشريحة بـ nums[i]، كما تفعل الحلقة الثالثة.
• فهرس النص إزاحة بايت. يشغل é بايتين، فيقفز الفهرس من 1 إلى 3.
• ترتيب الخريطة عشوائي عمدًا. تجعله Go عشوائيًا كي لا تعتمد الشيفرة عليه. تعطي slices.Sorted(maps.Keys(m)) (Go 1.23) المفاتيح مرتّبة.

تُشرح range كاملة في صفحة range، بما في ذلك القنوات ودوال المكرِّر وقواعد النسخ.

break وcontinue

تنهي break أعمق حلقة. وتقفز continue إلى التكرار التالي (بعد تنفيذ post أولًا في الحلقة ذات الأجزاء الثلاثة):

package main

import "fmt"

func main() {
	for i := range 10 {
		if i%2 == 0 {
			continue // skip even numbers
		}
		if i > 7 {
			break // stop entirely
		}
		fmt.Print(i, " ")
	}
	fmt.Println()
}

break وcontinue مع الوسوم

break العادية تخرج فقط من أعمق حلقة. للخروج من حلقة خارجية من داخل حلقة متداخلة، ضع وسمًا على الحلقة الخارجية:

package main

import "fmt"

func main() {
	grid := [][]int{
		{1, 2, 3},
		{4, 42, 6},
		{7, 8, 9},
	}

	target := 42
	found := false

search:
	for r, row := range grid {
		for c, v := range row {
			if v == target {
				fmt.Printf("found %d at row %d, col %d\n", target, r, c)
				found = true
				break search
			}
		}
	}
	fmt.Println("found:", found)

	// continue with a label skips to the outer loop's next iteration
rows:
	for _, row := range grid {
		for _, v := range row {
			if v%2 == 0 {
				fmt.Println("row with first even number", v)
				continue rows
			}
		}
	}
}

الوسم معرّف تليه نقطتان، يوضع مباشرة قبل for. تبلغ Go عن الوسم غير المستخدم كخطأ ترجمة، تمامًا مثل المتغيّر غير المستخدم.

break داخل switch وselect

داخل for، تخرج break في حالة من حالات switch أو select من switch أو select، لا من الحلقة:

for {
	switch cmd := next(); cmd {
	case "quit":
		break // only exits the switch; the loop keeps running
	}
}

استخدم break بوسم، أو return، للخروج من الحلقة من داخل switch أو select.

متغيّرات الحلقة منذ Go 1.22

غيّرت Go 1.22 نطاق متغيّرات الحلقة: كل تكرار يحصل الآن على نسخة جديدة من i وv. سابقًا كان متغيّر واحد يُعاد استخدامه للحلقة كلها، وهذا كان يكسر الإغلاقات والـ goroutines التي تلتقطه:

package main

import (
	"fmt"
	"sync"
)

func main() {
	var funcs []func()
	for i := range 3 {
		funcs = append(funcs, func() { fmt.Print(i, " ") })
	}
	for _, f := range funcs {
		f()
	}
	fmt.Println()

	var wg sync.WaitGroup
	results := make([]string, 3)
	for i, name := range []string{"a", "b", "c"} {
		wg.Add(1)
		go func() {
			defer wg.Done()
			results[i] = name + name
		}()
	}
	wg.Wait()
	fmt.Println(results)
}

مع Go 1.22 وما بعده يطبع هذا 0 1 2 و[aa bb cc]. بالدلالات القديمة كان البرنامج نفسه مكتوبًا بـ for i := 0; i < 3; i++ (لم يكن المرور بـ range على عدد صحيح موجودًا قبل 1.22) يطبع 3 3 3، وكانت الـ goroutines تتسابق على i وname المشتركين. الحل القديم، i := i في أول جسم الحلقة، لم يعد ضروريًا.

يُختار السلوك لكل وحدة حسب سطر go في go.mod، لا حسب إصدار المترجم. الوحدة التي ما زالت تذكر go 1.21 تحتفظ بالدلالات القديمة حتى عند بنائها بـ Go 1.24.

أخطاء شائعة

تعديل النسخة. for _, v := range items { v.Count++ } تغيّر نسخة. استخدم items[i].Count++، أو مرّ على شريحة من المؤشرات.

الإلحاق أثناء المرور. تقيّم range الشريحة مرة واحدة في البداية. العناصر الملحقة داخل الحلقة لا تُزار، فتنتهي الحلقة، لكنها لن ترى العناصر الجديدة.

الحذف من شريحة بالفهرس في حلقة تسير إلى الأمام. حذف العنصر i يقدّم كل ما بعده موضعًا واحدًا، فيُتخطّى العنصر التالي. ابنِ شريحة جديدة، أو امشِ في الحلقة بالعكس، أو استخدم slices.DeleteFunc.

الانزياح بمقدار واحد مع <=. تقرأ for i := 0; i <= len(s); i++ العنصر s[len(s)] في المرور الأخير وتسبّب panic برسالة index out of range. استخدم <، أو الأفضل range.

عمل ثقيل في الشرط. يُنفَّذ الشرط في كل تكرار. for i := 0; i < expensiveCount(); i++ تستدعي الدالة في كل مرة؛ احسبها مرة واحدة قبل الحلقة.

استخدام عدد عشري كعدّاد. for x := 0.0; x != 1.0; x += 0.1 لا تنتهي أبدًا، لأن 0.1 ليس لها تمثيل ثنائي دقيق. عُدّ بعدد صحيح واحسب العدد العشري منه.

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