defer, panic आणि recover हे काय करतात?

Question

Accepted Answer

हे तीन keywords विलंबित अंमलबजावणी आणि असाधारण परिस्थितींचे हाताळणी करतात। **`defer`** क्लीनअप शेड्यूल करते, **`panic`** रनटाइम क्रॅश ट्रिगर करते (खरोखर असाधारण प्रकरणांसाठी), आणि **`recover`** प्रोग्राम क्रॅश होण्यापासून रोखण्यासाठी panic पकडू शकते।

## defer — फंक्शन परत आल्यावर कॉल शेड्यूल करा

```go
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` फंक्शन कॉल शेड्यूल करते जे सभोवतालचे फंक्शन परत आल्यावर कार्यान्वित होते — ते कसेही परत आले (सामान्य रिटर्न, त्रुटी, किंवा panic). हे क्लीनअप सुनिश्चित करण्याचा मूर्तिमान मार्ग आहे: फाइलें बंद करणे, मিউटेक्स अनलॉक करणे, कनेक्शन बंद करणे — अधिग्रहणाच्या बगल मध्ये ठेवले जाते म्हणजे आपण त्याबद्दल विसरू शकत नाही.

## एकाधिक defers LIFO क्रमात चालतात

```go
defer fmt.Println("1")
defer fmt.Println("2")
defer fmt.Println("3")
// prints: 3, 2, 1 — last deferred, first executed (stack order)
```

## panic — खरोखर असाधारण, पुनर्प्राप्य न होणार्या परिस्थितींसाठी

```go
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` सामान्य प्रवाह थांबवते आणि कॉल स्टॅक unwound करते (मार्गावर defer केलेले फंक्शन चालवून), अखेरीस प्रोग्राम क्रॅश करते. हे **प्रोग्रामर त्रुटी / पुनर्प्राप्य न होणार्या परिस्थितींसाठी** आहे (bounds बाहेर, nil dereference, अशक्य states) — सामान्य त्रुटींसाठी नाही (ती returned `error` मूल्यांचा वापर करतात).

## recover — panic पकडा (केवळ deferred फंक्शनच्या आत)

```go
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 वर नियंत्रण परत मिळवते — परंतु **केवळ deferred फंक्शनच्या आत कार्य करते**. हे दुर्लभपणे वापरले जाते, उदा. एकल विनंती हाँडलर पूर्ण सर्व्हरला क्रॅश होण्यापासून रोखण्यासाठी.

## मुख्य तत्व: सामान्य त्रुटींसाठी panic/recover वापर करू नका

```text
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` एक आवश्यक, मूर्तिमान Go feature आहे **हमी क्लीनअप** साठी — संसाधन रिलीज अधिग्रहणाच्या बगल मध्ये ठेवून आणि प्रत्येक return पथावर (panics समावेश) चालवण्याची हमी देते, जे leaked फाइलें, locks, आणि कनेक्शनांना अधिक विश्वसनीयपणे रोखते.

त्याचे LIFO क्रमांचे समज महत्वाचे आहे देखील. `panic`/`recover` एक exception-like यंत्रणा प्रदान करतात, परंतु **महत्वाचा तत्व** असा आहे की Go त्यांना खरोखर असाधारण, पुनर्प्राप्य न होणार्या परिस्थितींसाठी राखते — सामान्य त्रुटी नेहमी मूल्य म्हणून परत केल्या पाहिजेत आणि तपासल्या पाहिजेत.

Panic/recover ला सामान्य exception handling म्हणून गैरवापर करणे un-idiomatic आहे आणि exception-based भाषांमधून येणार्या developers साठी सामान्य चूक आहे.

`defer` (नेहमी, क्लीनअपसाठी), `error` returns (सामान्य अपयश), आणि `panic`/`recover` (दुर्लभ, असाधारण, किंवा सीमेवर) कधा वापर करायचे हे जाणणे हे योग्य, idiomatic Go लिहिण्यासाठी मूलभूत आहे आणि वारंवार interview विषय आहे.