ఈ మూడు 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 చేస్తుంది ఎందుకంటే surrounding function return అయినప్పుడు execute అవుతుంది — ఎలా return అయినా సరిగ్గా (normal return, error, లేదా panic). ఇది cleanup ను ensure చేసే idiomatic way: files ను closing చేయడం, mutexes ను unlocking చేయడం, connections ను closing చేయడం — అధిగ్రహణ పక్కన ఉంచబడుతుంది కాబట్టి మీరు దానిని మర్చిపోలేరు.
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 ను running చేస్తుంది), చివరకు program crash అవుతుంది. ఇది programmer errors / unrecoverable conditions కోసం (out-of-bounds, nil dereference, impossible states) — ordinary errors కోసం కాదు (ఆ returned error values ని use చేస్తుంది).
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 ను regain చేస్తుంది — కానీ only deferred function లో ఉంటే work చేస్తుంది. ఇది rarely use చేయబడుతుంది, ఉదాహరణకు single request handler ను whole server crash అయ్యకుండా stop చేయడానికి.
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 పక్కన ఉంచడం మరియు ప్రతి return path (panics including) పై run చేయబడుతుందని ensure చేయడం, ఇది leaked files, locks, మరియు connections ను manual cleanup కంటే చాలా reliable way ఫలితంగా prevent చేస్తుంది.
ఈ LIFO ordering ను understanding చేయడం కూడా important. panic/recover ఒక exception-like mechanism ను provide చేస్తాయి, కానీ critical principle ఏమిటంటే Go ఆ genuinely exceptional, unrecoverable situations కోసం reserve చేస్తుంది — normal errors ఎప్పుడూ values として returned మరియు checked ఉండాలి.
Panic/recover ను general exception handling చేయడం un-idiomatic మరియు exception-based languages నుండి coming developers కోసం ఒక common mistake.
defer (ఎప్పుడూ, cleanup కోసం), error returns (normal failures), మరియు panic/recover (rare, exceptional, లేదా boundaries) ను ఎప్పుడు use చేయాలో knowing చేయడం correct, idiomatic Go writing చేయడానికి fundamental మరియు frequent interview topic.