Go નો control flow જાણીતરીતે ન્યૂનતમ છે — ત્યાં માત્ર એક loop keyword (for) છે, conditions ની આસપાસ કોઈ parentheses નથી, અને અનિવાર્ય braces છે. આ સરળતા ઇરાદાપૂર્ણ છે, જે દરેક કામ કરવાનો એક સ્પષ્ટ રસ્તો આપે છે.
x > {
fmt.Println()
} x > {
fmt.Println()
} {
fmt.Println()
}
err := doSomething(); err != {
err
}
ં if init; condition form (if ની 범위માં variable ઘોષણા) Go માં અત્યંત સામાન્ય છે — ખાસ કરીને if err := ...; err != nil error-check pattern.
// 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 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 ાપયોગ કરો.
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 વાંચવા અને લખવા માટે મૂળભૂત છે.
વિગતવાર જવાબો સાથે IT ઇન્ટરવ્યૂ પ્રશ્નોની લાઇબ્રેરી — જુનિયરથી સિનિયર સુધી.
દાન કરો