के लिए: एकमात्र लूप

गो में एक एकल लूप निर्माण है: for। नहीं while, नहीं do-while, नहीं foreach (यह अगले पाठ में आता है range). एक एकल कीवर्ड तीन रूपों के कारण सभी मामलों को कवर करता है।

for के तीन रूप

क्लासिक तीन-खंड प्रपत्र

सी/जावा के समान:

for i := 0; i < 5; i++ {
    fmt.Println(i)
}

i का दायरा for तक सीमित है। तीन खंड वैकल्पिक हैं (आप कर सकते हैं उनमें से किसी को भी छोड़ दें) लेकिन यदि आप किसी मध्यवर्ती को छोड़ देते हैं तो ; बना रहता है।

"जबकि" रूप: केवल शर्त

गो में, while केवल एक for है जिसमें एकल bool अभिव्यक्ति है:

i := 0
for i < 5 {
    fmt.Println(i)
    i++
}

अनंत रूप

क्लॉज़ के बिना, लूप कभी समाप्त नहीं होता (जब तक break/return):

for {
    if exitCondition() {
        break
    }
    doWork()
}

यह इवेंट हैंडलिंग लूप, सर्वर, पुनः प्रयास नीतियों के लिए पैटर्न है।

break, continue और लेबल

break अंतरतम लूप से बाहर निकलता है, continue अगले पुनरावृत्ति पर जाता है:

for i := 0; i < 10; i++ {
    if i%2 == 0 {
        continue       // salta i pari
    }
    if i > 7 {
        break          // ferma il ciclo
    }
    fmt.Println(i)     // 1 3 5 7
}

नेस्टेड लूप से बाहर निकलने के लिए लेबल हैं (दुर्लभ लेकिन उपयोगी):

Esterno:
for i := 0; i < 3; i++ {
    for j := 0; j < 3; j++ {
        if i*j == 4 {
            break Esterno   // esce da entrambi
        }
    }
}

C जैसा कोई , ऑपरेटर नहीं है

गो में आप for i, j := 0, 10; i < j; i, j = i+1, j-1 नहीं लिख सकते: पोस्ट एक्सप्रेशन एकाधिक असाइनमेंट स्वीकार नहीं करता है। गो का प्रयोग करें एकाधिक असाइनमेंट सिंटैक्स:

for i, j := 0, 10; i < j; i, j = i+1, j-1 {
    fmt.Println(i, j)
}

इसके बजाय यह काम करता है क्योंकि i, j = i+1, j-1 एकल है एकाधिक असाइनमेंट.

इसे अजमाएं

// (a) for i := 0; i < 10; i++ { ... }
// (b) for cond { ... }
// (c) for { ... }

संक्षिप्त

• एक एकल कीवर्ड for तीन रूपों के साथ: क्लासिक, जबकि, अनंत।
• break / continue वैकल्पिक रूप से नेस्टेड लूप के लिए एक लेबल के साथ।
• for से पहले Name: लेबल करें, संयम से उपयोग करें।
• ऑपरेटर के रूप में कोई , नहीं: एकाधिक असाइनमेंट i, j = ..., ... का उपयोग करें।