కోసం...పరిధి

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 స్పష్టమైన పరిధితో: మీరు ఉపయోగించని వాటిని _తో విస్మరించండి.
• స్లైస్/అరే: ఇండెక్స్ + విలువ యొక్క కాపీ. మార్చడానికి, సూచిక.
• మ్యాప్: కీ + విలువ, ఆర్డర్ యాదృచ్ఛికం ప్రతి రన్‌లో.
• స్ట్రింగ్: పరిధి ప్రతి బైట్‌కి కాకుండా రూన్కి (కోడ్ పాయింట్) పునరావృతమవుతుంది.
• ఛానెల్: ఛానెల్ తెరిచినప్పుడు పునరావృతమవుతుంది; close()తో మూసివేయబడింది.