לולאת while ב-Golang: איך כותבים while ו-do-while ב-Go

ב-Go אין מילת מפתח while. כתבו for ואחריו תנאי, וקיבלתם לולאת while:

package main

import "fmt"

func main() {
	balance := 1000.0
	years := 0

	for balance < 2000 {
		balance *= 1.07
		years++
	}

	fmt.Printf("doubled after %d years: %.2f\n", years, balance)
}

התנאי נבדק לפני כל איטרציה, כך שאם הוא שקרי כבר בהתחלה, גוף הלולאה לא רץ אף פעם. זה זהה ל-while (balance < 2000) ב-C, ב-Java או ב-JavaScript, רק בלי הסוגריים ובלי מילת המפתח. המתכננים של Go בחרו במילת מפתח אחת לכל צורות הלולאה; בעמוד של לולאת for תמצאו את כל ארבע הצורות.

while(true): הלולאה האינסופית

השמיטו את התנאי לגמרי, והלולאה תרוץ עד שמשהו בתוכה יעצור אותה:

package main

import "fmt"

func main() {
	queue := []string{"email", "resize", "stop", "never-reached"}

	for {
		job := queue[0]
		queue = queue[1:]

		if job == "stop" {
			fmt.Println("stopping")
			break
		}
		fmt.Println("processing", job)
	}

	fmt.Println("left in queue:", queue)
}

for { } היא הכתיבה האידיומטית. גם for true { } מתקמפל, אבל הוא נקרא כאילו הכותב הגיע משפה אחרת.

ארבעה דברים עוצרים לולאה אינסופית: break (יוצא מהלולאה), return (יוצא מהפונקציה), panic ו-os.Exit. תוכנית שה-main שלה יושב בתוך for {} בלי אף אחד מאלה רצה עד שמישהו הורג אותה, וזה בדיוק מה שצריך בשרת או ב-worker.

do-while

do-while מריצה את גוף הלולאה פעם אחת לפני שהיא בודקת את התנאי. ל-Go אין תחביר ייעודי לכך. שימו את הבדיקה בסוף לולאה אינסופית:

package main

import (
	"fmt"
	"math/rand/v2"
)

func main() {
	r := rand.New(rand.NewPCG(8, 8))

	rolls := 0
	for {
		roll := r.IntN(6) + 1
		rolls++
		fmt.Println("rolled", roll)

		if roll == 6 {
			break
		}
	}
	fmt.Println("needed", rolls, "rolls to get a 6")
}

גוף הלולאה רץ לפחות פעם אחת בכל מקרה, וזו התכונה שמגדירה do-while. מקור האקראיות משתמש ב-seed קבוע, כך שהפלט זהה בכל הרצה; לאקראיות אמיתית השתמשו ב-rand.IntN בלי מקור עם seed.

צורה שנייה משאירה את התנאי בכותרת הלולאה בכך שהיא מכריחה את המעבר הראשון:

for first := true; first || condition(); first = false {
	// body
}

זה עובד, אבל הלולאה האינסופית עם break בסוף קריאה יותר, וזה מה שרוב קוד ה-Go עושה.

קריאה עד הסוף

לולאת ה-while הנפוצה ביותר בקוד Go אמיתי קוראת קלט עד שהוא נגמר. bufio.Scanner נבנה בדיוק בשביל זה: Scan מחזירה false בסוף הקלט או כשיש שגיאה, ולכן היא משמשת כתנאי הלולאה:

package main

import (
	"bufio"
	"fmt"
	"strings"
)

func main() {
	input := "first line\nsecond line\nthird line\n"
	scanner := bufio.NewScanner(strings.NewReader(input))

	n := 0
	for scanner.Scan() {
		n++
		fmt.Printf("%d: %s\n", n, scanner.Text())
	}
	if err := scanner.Err(); err != nil {
		fmt.Println("read error:", err)
	}
}

החליפו את strings.NewReader(input) ב-os.Stdin, ואותה לולאה תקרא את הקלט של המשתמש שורה אחר שורה. בדקו את scanner.Err() אחרי הלולאה: העובדה ש-Scan החזירה false לא אומרת אם הקלט הסתיים כרגיל או נכשל.

break ו-continue

שתיהן עובדות בכל הצורות של for:

package main

import "fmt"

func main() {
	n := 0
	for n < 20 {
		n++
		if n%3 != 0 {
			continue // back to the condition check
		}
		if n > 12 {
			break
		}
		fmt.Print(n, " ")
	}
	fmt.Println()
}

בלולאה עם תנאי בלבד, continue קופצת ישר לתנאי. זה מקל על באג עדין: אם המונה מתעדכן בסוף גוף הלולאה, continue שנמצאת לפניו מדלגת על העדכון, והלולאה לא נגמרת לעולם. עדכנו את המונה בהתחלה, כמו בדוגמה, או השתמשו ב-for עם שלושה חלקים, שבה פקודת ה-post רצה גם אחרי continue.

המתנה למשהו

לולאה שמחכה לתנאי צריכה להיחסם או לישון, לא להסתובב על ריק:

// Wrong: burns a CPU core while waiting
for !ready {
}

// Better: poll with a delay
for !isReady() {
	time.Sleep(100 * time.Millisecond)
}

דגימה חוזרת של משתנה רגיל ש-goroutine אחרת כותבת אליו היא גם data race. בין goroutines, חכו על channel, על sync.WaitGroup או על sync.Cond, או השתמשו ב-select עם טיימר. ללולאות ניסיון חוזר עם הגבלה, העדיפו for עם מונה, כדי שהלולאה לא תוכל לרוץ לנצח:

for attempt := 1; attempt <= 5; attempt++ {
	if err := connect(); err == nil {
		break
	}
	time.Sleep(time.Duration(attempt) * 200 * time.Millisecond)
}

טעויות נפוצות

• לשכוח לשנות את משתנה התנאי. for i < 10 { fmt.Println(i) } לא נגמרת לעולם. כל לולאת while צריכה משהו בגוף הלולאה שמקרב אותה ליציאה.
• לכתוב while. while x < 5 {} נותן syntax error: unexpected name x at end of statement, כי while אינה מילת מפתח; הקומפיילר קורא אותה כשם רגיל.
• סוגריים מתוך הרגל. for (x < 5) {} מתקמפל, ו-gofmt מסיר את הסוגריים.
• להצהיר על המשתנה בתוך הלולאה. for n := 10; n > 0 {} היא שגיאת תחביר; לולאה עם פסוקית אתחול צריכה את כל שלושת החלקים. הצהירו על n לפני הלולאה, או כתבו את הצורה המלאה עם שלושה חלקים.

for count < 10 {
	count++
}

for {
	// body runs at least once
	if !condition {
		break
	}
}