ל...טווח

for ... range היא הדרך האידיומטית לחזור על אוספים: פרוסות, מערכים, מפות, מחרוזות וערוצים. התחביר משתנה מעט תלוי באוסף, אבל תבנית הבסיס תמיד זהה: for key, value := range coll { ... }.

טווח על פרוסות ומערכים

מחזירה אינדקס ועותק של הערך:

nums := []int{10, 20, 30}
for i, v := range nums {
    fmt.Println(i, v)
}
// 0 10
// 1 20
// 2 30

לעתים קרובות אחד מהשניים מספיק:

// solo indice
for i := range nums { _ = i }

// solo valore (ignora indice con _)
for _, v := range nums { _ = v }

טווח במפה

מחזירה מפתח וערך:

prices := map[string]int{"pane": 2, "latte": 3, "vino": 8}
for k, v := range prices {
    fmt.Println(k, v)
}

טווח על מחרוזת: רונים, לא בייטים

for i, r := range s חוזרות לכל נקודת קוד Unicode (רונה), לא לפי בייט. האינדקס i הוא היסט בתים של תחילת הרונה.

for i, r := range "èé" {
    fmt.Printf("%d %c (%U)\n", i, r, r)
}
// 0 è (U+00E8)
// 2 é (U+00E9)

כדי לחזור על כל בייט השתמש באינדקס קלאסי:

s := "ciao"
for i := 0; i < len(s); i++ {
    fmt.Println(s[i])  // byte (uint8)
}

טווח בערוץ

חוזר עד לסגירת הערוץ:

ch := make(chan int)
go func() {
    for i := 0; i < 3; i++ { ch <- i }
    close(ch)
}()
for v := range ch {
    fmt.Println(v)
}

נחפור לעומק במודול Concurrency.

נסה את זה

m := map[string]int{"a": 1, "b": 2}
for k, v := range m { fmt.Println(k, v) }

לְסַכֵּם

• for k, v := range coll עם היקף ברור: השלך עם _ את מה שאינך משתמש בו.
• פרוסה/מערך: אינדקס + עותק של הערך. כדי לבצע מוטציה, אינדקס.
• מפה: מפתח + ערך, הזמנה אקראית בכל ריצה.
• מחרוזת: טווח חוזר לכל רונה (נקודת קוד), לא לכל בייט.
• ערוץ: חוזר בזמן שהערוץ פתוח; נסגר עם close().