תיעוד Go עם דוגמאות להרצה: לולאות range

Q: מה range מחזירה ב-Go?

זה תלוי באופרנד. ל-slice או למערך: אינדקס ואיבר. למחרוזת: אינדקס של בייט ו-rune. ל-map: מפתח וערך. ל-channel: כל ערך שמתקבל. למספר שלם n (Go 1.22): מ-0 עד n פחות 1. לפונקציית iterator (Go 1.23): מה שהפונקציה מעבירה ל-yield. אפשר להשמיט את המשתנה השני, או לזרוק את הראשון עם _.

Q: למה שינוי של ערך ה-range לא משנה את ה-slice שלי?

משתנה הערך הוא עותק של האיבר. for _, v := range items { v.Price = 0 } משנה רק את העותק. השתמשו באינדקס במקום זה: for i := range items { items[i].Price = 0 }, או עברו עם range על slice של pointers.

Q: אפשר לעשות range על מספר שלם ב-Go?

כן, מאז Go 1.22: for i := range 5 { ... } רצה עם i מ-0 עד 4. for range 5 { ... } חוזרת חמש פעמים בלי משתנה. ב-go.mod של המודול חייב להיות כתוב go 1.22 ומעלה.

Q: בטוח למחוק מ-map בזמן range עליו?

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

range היא הצורה של for שעוברת על אוסף. היא נותנת ערך אחד או שניים בכל איטרציה, ומה הערכים האלה תלוי בטיפוס שעליו עושים range:

אופרנד	ערך ראשון	ערך שני	הערות
slice `[]T`, מערך `[n]T`	אינדקס `int`	איבר `T`, עותק
pointer למערך `*[n]T`	אינדקס	איבר
מחרוזת	אינדקס של בייט `int`	`rune`	מפענחת UTF-8
map `map[K]V`	מפתח `K`	ערך `V`	סדר אקראי
channel `chan T`	איבר `T`	אין	עד שה-channel נסגר
מספר שלם `n`	מ-0 עד n פחות 1	אין	Go 1.22
`func(yield func() bool)`	אין	אין	Go 1.23
`func(yield func(V) bool)`	`V`	אין	Go 1.23
`func(yield func(K, V) bool)`	`K`	`V`	Go 1.23

package main

import "fmt"

func main() {
	for i, s := range []string{"a", "b"} {
		fmt.Println("slice", i, s)
	}
	for i, r := range "hé" {
		fmt.Println("string", i, string(r))
	}
	for k, v := range map[string]int{"x": 1} {
		fmt.Println("map", k, v)
	}
	ch := make(chan int, 2)
	ch <- 10
	ch <- 20
	close(ch)
	for v := range ch {
		fmt.Println("channel", v)
	}
	for i := range 2 {
		fmt.Println("int", i)
	}
}

לבחור אילו משתנים מקבלים

for i, v := range s {}  // both
for i := range s {}     // index (or key) only
for _, v := range s {}  // value only
for range s {}          // neither: just repeat len(s) times

הצהרה על משתנה שלא משתמשים בו היא שגיאת קומפילציה, אז השמיטו או החליפו ב-_ את מה שלא צריך. for range 3 {} היא הדרך הקצרה ביותר לחזור על משהו שלוש פעמים.

הערך הוא עותק

בכל איטרציה, האיבר מועתק למשתנה הערך. שינוי המשתנה לא משנה את האוסף:

package main

import "fmt"

type Item struct {
	Name  string
	Price int
}

func main() {
	items := []Item{{"pen", 3}, {"book", 12}}

	for _, it := range items {
		it.Price *= 2 // changes the copy
	}
	fmt.Println(items)

	for i := range items {
		items[i].Price *= 2 // changes the element
	}
	fmt.Println(items)

	ptrs := []*Item{{"cup", 5}}
	for _, p := range ptrs {
		p.Price = 1 // p is a copy of the pointer, but points at the real Item
	}
	fmt.Println(*ptrs[0])
}

העתקה גם עולה זמן כשהאיברים הם structs גדולים. ב-slice של structs גדולים, for i := range s עם s[i] חוסך את ההעתקה.

מחרוזות מחזירות runes

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

package main

import "fmt"

func main() {
	for i, r := range "añ語!" {
		fmt.Printf("byte %d: %c (U+%04X)\n", i, r, r)
	}

	// invalid UTF-8 yields U+FFFD and advances one byte
	for i, r := range "a\xffb" {
		fmt.Printf("byte %d: %q\n", i, r)
	}
}

כדי לעבור על בייטים במקום על תווים, השתמשו בלולאה עם אינדקס, for i := 0; i < len(s); i++, או עשו range על []byte(s). ראו את העמוד על runes ו-bytes לפרטים על UTF-8.

Maps: סדר אקראי

סדר המעבר על map לא מוגדר, וה-runtime הופך אותו לאקראי כדי שקוד לא יתחיל להסתמך על סדר אחד. לפלט דטרמיניסטי, מיינו את המפתחות:

package main

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

func main() {
	stock := map[string]int{"pears": 4, "apples": 10, "figs": 0}

	for _, k := range slices.Sorted(maps.Keys(stock)) {
		fmt.Println(k, stock[k])
	}

	// deleting during iteration is allowed
	for k, v := range stock {
		if v == 0 {
			delete(stock, k)
		}
	}
	fmt.Println(len(stock), stock)
}

מחיקת רשומות בזמן range בטוחה, ורשומה שנמחקה לפני שהלולאה הגיעה אליה לא מופיעה. הוספת רשומות מותרת אבל לא צפויה: מפתח חדש עשוי להופיע מאוחר יותר באותה לולאה ועשוי שלא. fmt.Println של map מדפיס את המפתחות ממוינים, וזו הסיבה שהשורה האחרונה יציבה.

Channels: עד שנסגרים

range על channel מקבל ערכים עד שה-channel נסגר ומתרוקן. אם אף אחד לא סוגר אותו, הלולאה נחסמת לנצח (ואם כל ה-goroutines חסומות, ה-runtime עוצר עם fatal error: all goroutines are asleep - deadlock!):

package main

import "fmt"

func produce(n int) <-chan int {
	out := make(chan int)
	go func() {
		defer close(out) // without this, the range below never ends
		for i := range n {
			out <- i * i
		}
	}()
	return out
}

func main() {
	for sq := range produce(5) {
		fmt.Print(sq, " ")
	}
	fmt.Println()
}

השולח סוגר את ה-channel, אף פעם לא המקבל. ראו את העמוד על channels ל-buffered channels ול-select.

מספרים שלמים (Go 1.22)

range n סופרת מ-0 ועד n, לא כולל. הטיפוס של משתנה הלולאה הוא הטיפוס של n:

for i := range 3 {}         // i is int: 0, 1, 2
for i := range uint8(3) {}  // i is uint8
for range 0 {}              // runs zero times

גם n שלילי רץ אפס פעמים. n מחושב פעם אחת, לפני שהלולאה מתחילה.

מה range מחשבת, ומתי

הביטוי שאחרי range מחושב פעם אחת, לפני האיטרציה הראשונה. ב-slice, range משתמשת אחר כך ב-header של אותו slice, כך שהאורך שלו קבוע:

package main

import "fmt"

func main() {
	nums := []int{1, 2, 3}
	for i, v := range nums {
		if i == 0 {
			nums[2] = 30            // visited: same backing array
			nums = append(nums, 99) // not visited
		}
		fmt.Print(v, " ")
	}
	fmt.Println()
	fmt.Println(nums)

	arr := [3]int{1, 2, 3}
	for i, v := range arr { // the array itself is copied
		if i == 0 {
			arr[2] = 30
		}
		fmt.Print(v, " ")
	}
	fmt.Println()
}

ה-99 שנוסף אף פעם לא מבוקר, כי אורך הלולאה נקבע על 3. אבל nums[2] = 30 כן נראה, כי בנקודה הזאת nums עדיין חולק את מערך הבסיס שלו עם ה-slice שעליו עושים range. החליפו את סדר שתי השורות וגם ה-30 נעלם: ה-append עובר את ה-capacity של 3, מקצה מערך חדש, והכתיבה נוחתת שם. range על ערך של מערך מעתיק קודם את כל המערך, ולכן השינוי ב-arr[2] לא נראה; עשו range על &arr או על arr[:] כדי להימנע מההעתקה.

range על פונקציות (Go 1.23)

מאז Go 1.23, range מקבלת גם פונקציות iterator. iterator מקבל callback בשם yield, קורא לו פעם אחת לכל ערך, ועוצר כש-yield מחזירה false (מה שקורה כשגוף הלולאה מבצע break או return):

package main

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

// Countdown yields n, n-1, ..., 1.
func Countdown(n int) iter.Seq[int] {
	return func(yield func(int) bool) {
		for i := n; i > 0; i-- {
			if !yield(i) {
				return
			}
		}
	}
}

// Pairs yields adjacent pairs from a slice.
func Pairs(s []string) iter.Seq2[string, string] {
	return func(yield func(string, string) bool) {
		for i := 0; i+1 < len(s); i++ {
			if !yield(s[i], s[i+1]) {
				return
			}
		}
	}
}

func main() {
	for n := range Countdown(5) {
		if n == 2 {
			break // yield returns false, Countdown stops
		}
		fmt.Print(n, " ")
	}
	fmt.Println()

	for a, b := range Pairs([]string{"a", "b", "c"}) {
		fmt.Println(a, "->", b)
	}

	// standard library iterators
	for i, v := range slices.Backward([]string{"x", "y", "z"}) {
		fmt.Printf("%d:%s ", i, v)
	}
	fmt.Println()
	fmt.Println(slices.Sorted(maps.Values(map[string]int{"a": 3, "b": 1})))
}

iter.Seq[V] ו-iter.Seq2[K, V] הם השמות המקובלים לשתי צורות ה-iterator. הספרייה הסטנדרטית מחזירה אותם מ-slices.All, slices.Values, slices.Backward, maps.Keys, maps.Values, maps.All, וב-Go 1.24 גם מ-strings.SplitSeq, strings.Lines ו-bytes.SplitSeq. ה-iterator חייב לכבד את ערך ההחזרה של yield: קריאה נוספת ל-yield אחרי שהיא החזירה false נכנסת ל-panic.

משתני לולאה הם לכל איטרציה (Go 1.22)

מאז Go 1.22, המשתנים שמוצהרים ב-for ... range חדשים בכל איטרציה. לכידה של v ב-closure או ב-goroutine לוכדת את הערך של אותה איטרציה, ולא משתנה משותף שבסוף מחזיק את האיבר האחרון. לפני Go 1.22 הייתם צריכים v := v בתוך הלולאה; השורה הזאת עכשיו מיותרת. הכלל נקבע לפי גרסת ה-go ב-go.mod, כך שמודול ישן שומר על ההתנהגות הישנה.

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

לקיחת הכתובת של משתנה הערך. לפני Go 1.22, ptrs = append(ptrs, &v) שמר את אותה כתובת בכל פעם. מאז 1.22 הוא שומר כתובות שונות, אבל כל אחת מצביעה על עותק, לא על האיבר שב-slice. השתמשו ב-&items[i] כדי להצביע לתוך ה-slice.
ציפייה לסדר ב-map. פלט שנראה ממוין בבדיקה קטנה לא יישאר ממוין.
range על channel שאף אחד לא סוגר. הלולאה, וה-goroutine שמריצה אותה, מחכות לנצח.
range על מערך גדול לפי ערך. כל המערך מועתק קודם. עשו range על slice שלו במקום זה.

שאלות נפוצות

מה range מחזירה ב-Go?

זה תלוי באופרנד. ל-slice או למערך: אינדקס ואיבר. למחרוזת: אינדקס של בייט ו-rune. ל-map: מפתח וערך. ל-channel: כל ערך שמתקבל. למספר שלם n (Go 1.22): מ-0 עד n פחות 1. לפונקציית iterator (Go 1.23): מה שהפונקציה מעבירה ל-yield. אפשר להשמיט את המשתנה השני, או לזרוק את הראשון עם _.

למה שינוי של ערך ה-range לא משנה את ה-slice שלי?

משתנה הערך הוא עותק של האיבר. for _, v := range items { v.Price = 0 } משנה רק את העותק. השתמשו באינדקס במקום זה: for i := range items { items[i].Price = 0 }, או עברו עם range על slice של pointers.

אפשר לעשות range על מספר שלם ב-Go?

כן, מאז Go 1.22: for i := range 5 { ... } רצה עם i מ-0 עד 4. for range 5 { ... } חוזרת חמש פעמים בלי משתנה. ב-go.mod של המודול חייב להיות כתוב go 1.22 ומעלה.

בטוח למחוק מ-map בזמן range עליו?

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

מושגים קשורים