కోసం: ఏకైక లూప్

Goలో ఒకే లూప్ నిర్మాణం: for. కాదు while, నం do-while, కాదు foreach (అది తదుపరి పాఠంలో వస్తుంది range). ఒకే కీవర్డ్ మూడు ఫారమ్‌లకు ధన్యవాదాలు అన్ని కేసులను కవర్ చేస్తుంది.

for యొక్క మూడు రూపాలు

క్లాసిక్ మూడు-నిబంధన రూపం

C/Javaకి సారూప్యం:

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

i పరిధిని forకి పరిమితం చేసింది. మూడు నిబంధనలు ఐచ్ఛికం (మీరు చేయవచ్చు వాటిలో దేనినైనా విస్మరించండి) కానీ మీరు ఇంటర్మీడియట్‌ను వదిలివేస్తే ; మిగిలి ఉంటుంది.

"అయితే" రూపం: షరతు మాత్రమే

గోలో, కేవలం 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 = ..., ...ని ఉపయోగించండి.