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 ਵਿਚ scoped variable declare ਕਰਦੇ ਸਮੇਂ) 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 ਵਿਚ ਡਿਫ਼ਾਲਟ ਰੂਪ ਵਿਚ fall through ਨਹੀਂ ਹੁੰਦਾ (ਕੋਈ break ਲੋੜੀ ਨਹੀਂ) — ਉਸ classic bug ਨੂੰ ਖਤਮ ਕਰਦਾ ਹੈ। fallthrough keyword ਦਾ ਇਸਤੇਮਾਲ ਉਸ ਦੁਰਲੱਭ ਸਥਿਤੀ ਵਿਚ ਕਰੋ ਜਦੋਂ ਤੁਹਾਨੂੰ ਇਸ ਦੀ ਲੋੜ ਹੋ।
func readFile() {
f, _ := os.Open("file.txt")
defer f.Close() // runs when the function RETURNS — guaranteed cleanup
// ... use f ...
}
defer ਇੱਕ call ਨੂੰ schedule ਕਰਦਾ ਹੈ ਜੋ surrounding function return ਹੋਣ ਸਮੇਂ ਚਲਦੀ ਹੈ — cleanup ਲਈ idiomatic (ਫਾਈਲਾਂ ਬੰਦ ਕਰਨਾ, mutexes ਨੂੰ unlock ਕਰਨਾ)।
Go ਦਾ ਜਾਣ-ਬੁੱਝ ਕੇ minimal control flow ਇਸ ਦੇ simplicity philosophy ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ ਅਤੇ ਜਾਣਨ ਦੇ ਯੋਗ practical implications ਹਨ।
ਸਿਰਫ for ਹੋਣਾ (classic, while-style, infinite, ਅਤੇ range loops ਨੂੰ cover ਕਰਦੇ ਹੋਏ) ਮਤਲਬ ਹੈ ਇੱਕ consistent looping construct ਹੈ — range iterate ਕਰਨ ਦਾ idiomatic ਤਰੀਕਾ ਹੈ।
ਕੋਈ-parentheses, mandatory-braces syntax ਅਤੇ if init; cond form (ਖਾਸ ਕਰ ਕੇ if err := ...; err != nil) idiomatic Go ਨੂੰ ਆਕਾਰ ਦਿੰਦਾ ਹੈ। switch ਡਿਫ਼ਾਲਟ ਰੂਪ ਵਿਚ fall through ਨਹੀਂ ਹੁੰਦਾ C-family ਦੀ common bug ਖਤਮ ਕਰਦਾ ਹੈ, ਅਤੇ condition-less switch ਇੱਕ ਸਾਫ if/else ਬਦਲ ਹੈ।
ਅਤੇ defer ਇੱਕ distinctive, essential cleanup mechanism ਹੈ।
ਇਹਨਾਂ ਨੂੰ ਸਮਝਣਾ — ਅਤੇ ਕਿਵੇਂ ਉਹ ਦੂਸਰੀਆਂ languages ਤੋਂ ਵੱਖ ਹਨ (ਇੱਕ loop, no fall-through, defer) — idiomatic Go ਨੂੰ ਪੜ੍ਹਨ ਅਤੇ ਲਿਖਣ ਲਈ fundamental ਹੈ।