के लिए...रेंज

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)
}

हम Concurrency मॉड्यूल में गहराई से खोज करेंगे।

इसे अजमाएं

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

संक्षिप्त

• for k, v := range coll स्पष्ट दायरे के साथ: जो आप उपयोग नहीं करते उसे _ के साथ त्यागें।
• स्लाइस/सरणी: सूचकांक + मूल्य की प्रतिलिपि। उत्परिवर्तित करने के लिए, अनुक्रमणिका.
• मानचित्र: कुंजी + मान, प्रत्येक रन पर क्रम यादृच्छिक।
• स्ट्रिंग: रेंज प्रति रूण (कोड बिंदु) पर पुनरावृत्त होती है, प्रति बाइट पर नहीं।
• चैनल: चैनल खुला होने पर पुनरावृत्त होता है; close() के साथ बंद हुआ।