לולאת 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 נבדק לפני כל איטרציה. כשהוא false, הלולאה מסתיימת.
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)
}

ב-Go i++ הוא הוראה ולא ביטוי, ולכן 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)
}

זו הצורה הסטנדרטית לשרתים, ל-workers וללולאות קלט. for {} עם גוף ריק שורפת ליבת מעבד; בקוד אמיתי, הגוף נחסם על משהו (קריאה, קבלה מ-channel, 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 בתוך הלולאה לא היה משנה את ה-slice; כדי לשנות איברים, גשו ל-slice דרך האינדקס עם nums[i], כמו שהלולאה השלישית עושה.
• האינדקס של מחרוזת הוא היסט בבתים. é תופס שני בתים, ולכן האינדקס קופץ מ-1 ל-3.
• הסדר של map אקראי בכוונה. Go הופכת אותו לאקראי כדי שקוד לא יוכל להסתמך עליו. slices.Sorted(maps.Keys(m)) (Go 1.23) נותן את המפתחות לפי הסדר.

range מוסבר במלואו, כולל channels, פונקציות איטרטור וכללי ההעתקה, בדף על 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. קודם, משתנה אחד שימש לכל הלולאה, וזה שבר closures ו-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++, או עברו על slice של מצביעים.

הוספה בזמן מעבר עם range. range מחשב את ה-slice פעם אחת, בהתחלה. איברים שנוספים בתוך הלולאה לא נסרקים, כך שהלולאה עדיין מסתיימת, אבל היא לא תראה את הפריטים החדשים.

מחיקה מ-slice לפי אינדקס בלולאה קדימה. הסרת איבר i מזיזה את השאר מקום אחד אחורה, ולכן האיבר הבא מדולג. בנו slice חדש, עברו על הלולאה מהסוף להתחלה, או השתמשו ב-slices.DeleteFunc.

טעות של אחד עם <=. for i := 0; i <= len(s); i++ קורא את s[len(s)] בסיבוב האחרון ונכנס ל-panic עם index out of range. השתמשו ב-<, או עדיף, ב-range.

עבודה כבדה בתנאי. התנאי רץ בכל איטרציה. for i := 0; i < expensiveCount(); i++ קוראת לפונקציה בכל פעם; חשבו אותה פעם אחת לפני הלולאה.

שימוש ב-float כמונה. for x := 0.0; x != 1.0; x += 0.1 אף פעם לא מסתיימת, כי ל-0.1 אין ייצוג בינארי מדויק. ספרו עם מספר שלם וחשבו ממנו את ה-float.

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