Go में कौन-कौन से control-flow constructs होते हैं?

Question

Accepted Answer

Go का control flow जानबूझकर **न्यूनतम** रखा गया है — सिर्फ़ **एक ही loop keyword (`for`)** है, conditions के चारों ओर parentheses नहीं होते, और braces अनिवार्य हैं। यह सरलता इरादतन है, जो हर काम करने का एक स्पष्ट तरीका देती है। ## if — कोई parentheses नहीं, एक optional init statement के साथ ```go if x > 10 { // no parentheses around the condition; braces required fmt.Println("big") } else if x > 5 { fmt.Println("medium") } else { fmt.Println("small") } // if with an INIT statement — variable scoped to the if/else (very idiomatic) if err := doSomething(); err != nil { return err // `err` exists only within this if/else } ``` `if init; condition` रूप (एक variable घोषित करना जो if तक scoped हो) Go में बेहद आम है — खासकर `if err := ...; err != nil` error-check पैटर्न। ## for — एकमात्र loop, कई रूपों में ```go // 1. classic three-part for for i := 0; i < 10; i++ { ... } // 2. while-style (just a condition) for x < 100 { x *= 2 } // 3. infinite loop for { ... break ... } // loop forever until break // 4. range — iterate slices, maps, strings, channels for index, value := range mySlice { ... } for key, value := range myMap { ... } for i, char := range "héllo" { ... } // i is byte index, char is a rune for range channel { ... } ``` Go में **कोई `while` या `do-while`** नहीं है — `for` सभी looping ज़रूरतों को पूरा करता है। `range` रूप collections को iterate करने का idiomatic तरीका है। ## switch — C से साफ़-सुथरा (कोई fall-through नहीं) ```go switch day { case "Sat", "Sun": // multiple values per case fmt.Println("weekend") case "Mon": fmt.Println("monday") // NO break needed — Go does NOT fall through by default! default: fmt.Println("weekday") } // switch with no condition = clean if/else chain switch { case score >= 90: grade = "A" case score >= 80: grade = "B" default: grade = "F" } ``` C/Java के विपरीत, Go का `switch` default रूप से **fall through नहीं करता** (कोई `break` ज़रूरी नहीं) — जो उस classic bug को ख़त्म कर देता है। उस दुर्लभ स्थिति में जब आपको यह चाहिए, `fallthrough` keyword का उपयोग करें। ## defer — cleanup शेड्यूल करें ```go func readFile() { f, _ := os.Open("file.txt") defer f.Close() // runs when the function RETURNS — guaranteed cleanup // ... use f ... } ``` `defer` एक call को तब चलाने के लिए शेड्यूल करता है जब चारों ओर का function return करता है — cleanup के लिए idiomatic (files बंद करना, mutexes unlock करना)। ## यह क्यों महत्वपूर्ण है Go का जानबूझकर न्यूनतम रखा गया control flow इसके सरलता-दर्शन को दर्शाता है और इसके व्यावहारिक निहितार्थ जानने लायक हैं। **सिर्फ़ `for`** होने (classic, while-style, infinite, और range loops को कवर करते हुए) का मतलब है कि एक ही सुसंगत looping construct है — `range` ही iterate करने का idiomatic तरीका है। **no-parentheses, mandatory-braces** syntax और **`if init; cond`** रूप (खासकर `if err := ...; err != nil`) idiomatic Go को आकार देते हैं। `switch` का default रूप से **fall through न करना** एक आम C-family bug को ख़त्म करता है, और condition-less `switch` एक साफ़ if/else विकल्प है। और `defer` एक विशिष्ट, आवश्यक cleanup तंत्र है। इन्हें समझना — और ये दूसरी भाषाओं से कैसे भिन्न हैं (एक loop, कोई fall-through नहीं, defer) — idiomatic Go को पढ़ने और लिखने के लिए बुनियादी है।