Go मा कुन कुन control-flow constructs छन्?

Question

Accepted Answer

Go को control flow जानबूझकर **minimal** छ — त्यहाँ केवल एक loop keyword (`for`) छ, conditions वरिपरि parentheses छैनन्, र brace अनिवार्य छन्। यो सरलता intentional छ, प्रत्येक कुरालाई गर्न एक स्पष्ट तरीका दिन्छ। ## 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` form (if मा scoped variable declare गर्दा) Go मा अत्यन्त सामान्य छ — विशेष गरी `if err := ...; err != nil` error-check pattern। ## for — एकमात्र LOOP, धेरै forms मा ```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` form collections को iterate गर्ने idiomatic तरीका हो। ## switch — C भन्दा सफा (no 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 schedule गर्नुहोस् ```go func readFile() { f, _ := os.Open("file.txt") defer f.Close() // runs when the function RETURNS — guaranteed cleanup // ... use f ... } ``` `defer` surrounding function return गर्दा कल गर्न schedule गर्छ — cleanup को लागि idiomatic (files बन्द गर्ने, mutexes unlock गर्ने)। ## यो किन महत्त्वपूर्ण छ Go को deliberately minimal control flow यसको simplicity philosophy को प्रतिफलन गर्छ र जान्न योग्य practical implications छ। केवल **`for`** भएको (classic, while-style, infinite, र range loops लाई कभर गर्दा) भन्नु भएको एक consistent looping construct छ — `range` iterate गर्ने idiomatic तरीका हो। **parentheses छैनन्, mandatory-braces** syntax र **`if init; cond`** form (विशेष गरी `if err := ...; err != nil`) idiomatic Go को आकार दिन्छ। `switch` **default मा fall through हुँदैन** C-family को common bug हटाउँछ, र condition-less `switch` एक सफा if/else alternative हो। र `defer` एक distinctive, essential cleanup mechanism हो। यी बुझ्न — र कसरी तिनीहरू अन्य languages को भन्दा फरक छन् (एक loop, no fall-through, defer) — Go पढ्न र लेख्न idiomatic को लागि fundamental छ।