Go માં કયા control-flow constructs છે?

Question

Accepted Answer

Go નો control flow જાણીતરીતે **ન્યૂનતમ** છે — ત્યાં માત્ર **એક loop keyword (`for`)** છે, conditions ની આસપાસ કોઈ parentheses નથી, અને અનિવાર્ય braces છે. આ સરળતા ઇરાદાપૂર્ણ છે, જે દરેક કામ કરવાનો એક સ્પષ્ટ રસ્તો આપે છે. ## if — કોઈ parentheses નથી, વૈકલ્પિક 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 ની 범위માં variable ઘોષણા) 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 કરતાં સ્વચ્છ (કોઈ 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` જરૂરી નથી) — તે ક્લાસિક 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` એક કૉલ ને શેડ્યુલ કરે છે કે જે આસપાસના function return થાય ત્યારે ચલાશે — cleanup (files બંધ કરવી, mutexes અનલૉક કરવી) માટે idiomatic. ## શા માટે તેનું મહત્વ છે Go નો જાણીતરીતે ન્યૂનતમ control flow તેનો સરળતાનો ફિલસૂફી પ્રતિબિંબિત કરે છે અને તેનાં વ્યાવહારિક અર્થો છે જે જાણવા યોગ્ય છે. માત્ર **`for`** હોવું (classic, while-style, infinite, અને range loops ને આવરી લેતું) એટલે એક સુસંગત looping construct છે — `range` એ iterate કરવાનો idiomatic રીત છે. ં **কোઈ parentheses નથી, અનિવાર્ય braces** સિન્ટેક્સ અને **`if init; cond`** form (ખાસ કરીને `if err := ...; err != nil`) idiomatic Go ને આકાર આપે છે. `switch` **default રીતે fall through નથી કરતો** એક સામાન્ય C-family bug ને દૂર કરે છે, અને condition-less `switch` એ ચોખ્ખો if/else વિકલ્પ છે. અને `defer` એક વિશિષ્ટ, આવશ્યક cleanup મિકેનિজમ છે. આ બાબતોને સમજવું — અને કેવી રીતે તેઓ અન્ય languages (એક loop, કોઈ fall-through, defer) થી અલગ છે — idiomatic Go વાંચવા અને લખવા માટે મૂળભૂત છે.