ਇਹ ਤਿੰਨ keywords delayed execution ਅਤੇ exceptional situations ਨੂੰ handle ਕਰਦੇ ਹਨ। defer cleanup ਨੂੰ schedule ਕਰਦਾ ਹੈ, panic runtime crash trigger ਕਰਦਾ ਹੈ (truly exceptional cases ਲਈ), ਅਤੇ recover panic ਨੂੰ catch ਕਰ ਸਕਦਾ ਹੈ ਤਾਂ ਜੋ program crash ਨਾ ਹੋਵੇ।
func readFile() error {
f, err := os.Open("file.txt")
if err != nil { return err }
defer f.Close() // GUARANTEED to run when readFile returns (any path)
// ... use f, with multiple return points ...
return nil // f.Close() runs here automatically
}
defer ਨੂੰ function call schedule ਕਰਦਾ ਹੈ ਤਾਂ ਜੋ ਇਹ execute ਹੋਵੇ ਜਦੋਂ surrounding function return ਹੋਵੇ — ਭਾਵੇਂ ਇਹ ਕਿਸੇ ਵੀ ਤਰੀਕੇ ਨਾਲ return ਹੋਵੇ (normal return, error, ਜਾਂ panic)। ਇਹ cleanup ਨੂੰ ensure ਕਰਨ ਦਾ idiomatic ਤਰੀਕਾ ਹੈ: files ਨੂੰ close ਕਰਨਾ, mutexes ਨੂੰ unlock ਕਰਨਾ, connections ਨੂੰ close ਕਰਨਾ — acquisition ਦੇ ਬਿਲਕੁਲ ਅਗਲ ਰੱਖਿਆ ਜਾਂਦਾ ਹੈ ਤਾਂ ਜੋ ਤੁਸੀਂ ਇਸ ਨੂੰ ਭੁੱਲ ਨਾ ਸਕੋ।
defer fmt.Println("1")
defer fmt.Println("2")
defer fmt.Println("3")
// prints: 3, 2, 1 — last deferred, first executed (stack order)
func mustPositive(n int) {
if n < 0 {
panic("negative not allowed") // stops normal execution, unwinds the stack
}
}
// panic runs deferred functions as it unwinds, then crashes the program (with a stack trace)
panic normal flow ਨੂੰ stop ਕਰਦਾ ਹੈ ਅਤੇ call stack ਨੂੰ unwind ਕਰਦਾ ਹੈ (deferred functions ਨੂੰ ਰਸਤੇ ਵਿੱਚ run ਕਰਦੇ ਹੋਏ), ਅੰਤ ਵਿੱਚ program ਨੂੰ crash ਕਰਦਾ ਹੈ। ਇਹ programmer errors / unrecoverable conditions ਲਈ ਹੈ (out-of-bounds, nil dereference, impossible states) — ordinary errors ਲਈ ਨਹੀਂ (ਜੋ returned error values ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਨ)।
func safeProcess() {
defer func() {
if r := recover(); r != nil { // recover() returns the panic value
fmt.Println("recovered from:", r) // handle it; program continues
}
}()
panic("something broke") // this panic is caught by the recover above
}
// safeProcess returns normally instead of crashing
recover panicking goroutine ਦਾ control ਮੁੜ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ — ਪਰ ਸਿਰਫ deferred function ਦੇ ਅੰਦਰ ਕੰਮ ਕਰਦਾ ਹੈ। ਇਸ ਨੂੰ ਘੱਟ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ single request handler ਨੂੰ ਪੂਰੇ server ਨੂੰ crash ਕਰਨ ਤੋਂ ਰੋਕਣ ਲਈ।
Normal/expected failures (file missing, bad input, validation) → return an error value
panic/recover → reserve for TRULY exceptional cases (bugs, unrecoverable states)
and boundaries (e.g. a server recovering so one bad request doesn't kill the process)
defer ਇੱਕ essential, idiomatic Go feature ਹੈ guaranteed cleanup ਲਈ — resource release ਨੂੰ acquisition ਦੇ ਬਿਲਕੁਲ ਅਗਲ ਰੱਖਿਆ ਜਾਂਦਾ ਹੈ ਅਤੇ ਇਹ ensure ਕਰਦਾ ਹੈ ਕਿ ਇਹ ਹਰ return path ਉੱਤੇ run ਹੋਵੇ (panics ਸਮੇਤ), ਜੋ leaked files, locks, ਅਤੇ connections ਨੂੰ manual cleanup ਨਾਲੋਂ ਕਿਤੇ ਜ਼ਿਆਦਾ reliably prevent ਕਰਦਾ ਹੈ।
ਇਸ ਦੇ LIFO ordering ਨੂੰ ਸਮਝਣਾ ਵੀ ਮਹੱਤਵਪੂਰਨ ਹੈ। panic/recover ਇੱਕ exception-like mechanism ਪ੍ਰਦਾਨ ਕਰਦੇ ਹਨ, ਪਰ critical principle ਇਹ ਹੈ ਕਿ Go ਇਨ੍ਹਾਂ ਨੂੰ genuinely exceptional, unrecoverable situations ਲਈ reserve ਕਰਦਾ ਹੈ — normal errors ਨੂੰ ਹਮੇਸ਼ਾ values ਦੇ ਰੂਪ ਵਿੱਚ return ਕਿਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ ਅਤੇ checked ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ।
General exception handling ਦੇ ਤੌਰ ਤੇ panic/recover ਦੀ ਗਲਤ ਵਰਤੋਂ un-idiomatic ਹੈ ਅਤੇ exception-based languages ਤੋਂ ਆਉਣ ਵਾਲੇ developers ਲਈ ਇੱਕ ਆਮ ਗਲਤੀ ਹੈ।
ਇਹ ਜਾਣਨਾ ਕਿ defer (ਹਮੇਸ਼ਾ, cleanup ਲਈ), error returns (normal failures), ਅਤੇ panic/recover (rare, exceptional, ਜਾਂ boundaries ਉੱਤੇ) ਕਦੋਂ ਵਰਤਣੇ ਹਨ, ਇਹ correct, idiomatic Go ਲਿਖਣ ਲਈ fundamental ਹੈ ਅਤੇ ਇੱਕ frequent interview topic ਹੈ।