வரம்பிற்கு

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 மீண்டும் ஒவ்வொரு யூனிகோட் குறியீடு புள்ளிக்கு (ரூன்), ஒன்றுக்கு அல்ல பைட். குறியீட்டு 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)
}

கன்கரன்சி தொகுதியில் ஆழமாக தோண்டுவோம்.

முயற்சி செய்து பாருங்கள்

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

மறுபரிசீலனை

• for k, v := range coll தெளிவான நோக்கத்துடன்: நீங்கள் பயன்படுத்தாதவற்றை _ உடன் நிராகரிக்கவும்.
• துண்டு/வரிசை: குறியீட்டு + மதிப்பின் நகல். To mutate, index.
• வரைபடம்: விசை + மதிப்பு, ஒவ்வொரு ஓட்டத்திலும் ** சீரற்ற** ஆர்டர்.
• சரம்: வரம்பு ஒரு பைட்டுக்கு அல்ல, ரூனுக்கு (குறியீட்டுப் புள்ளி) திரும்பும்.
• சேனல்: சேனல் திறந்திருக்கும் போது மீண்டும் செய்கிறது; close() உடன் மூடப்பட்டது.