defer, panic மற்றும் recover என்ன செய்கின்றன?

Question

Accepted Answer

இந்த மூன்று keywords முறையிட்ட செயல்பாடு மற்றும் விதிவிலக்கு சூழ்நிலைகளை கையாளுகின்றன. **`defer`** சுத்தம் செய்யும் பணிகளை திட்டமிடுகிறது, **`panic`** ஒரு runtime செயலிழப்பைத் தூண்டுகிறது (உண்மையான விதிவிலக்கு சூழ்நிலைகளுக்கு), மற்றும் **`recover`** ஒரு panic ஐ பிடிக்க முடியும் நிரல் செயலிழப்பு தடுக்க.

## defer — function திரும்பும் போது ஒரு call ஐ திட்டமிடுக

```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` ஒரு function call ஐ செயல்படுத்த திட்டமிடுகிறது சுற்றியுள்ள function திரும்பும் போது — அது எப்படி திரும்பினாலும் (சாதாரண திரும்பல், error, அல்லது panic). இது சுத்தம் செய்வதை உறுதிப்படுத்த idiomatic வழி: கோப்புகளை மூடுதல், mutexes ஐ திறத்தல், இணைப்புகளை மூடுதல் — பெறுவதற்கு அடுத்தாக வைக்கப்பட்டு நீங்கள் அதை மறக்க முடியாது.

## பல 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` சாதாரண ప్రవाহ ஐ நிறுத்தி call stack ஐ அவிழ்க்கிறது (வழியில் deferred functions ஐ இயங்குகிறது), இறுதியாக நிரல் செயலிழப்பு. இது **programmer errors / மீண்டும் பெற முடியாத நிலைமைகள்** க்கு (out-of-bounds, nil dereference, impossible states) — சாதாரண errors க்கு அல்ல (அவை திரும்பிய `error` மதிப்புகளைப் பயன்படுத்துகிறது).

## recover — ஒரு panic ஐ பிடிக்க (deferred function க்குள் மட்டுமே)

```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 function க்குள் மட்டுமே வேலை செய்கிறது**. இது hiறுக்கமாக பயன்படுத்தப்படுகிறது, உ.ம். ஒரு முழு server ஐ செயலிழப்பு செய்வதிலிருந்து ஒரு வேண்டுகோள் handler ஐ நிறுத்த.

## முக்கிய கொள்கை: சாதாரண errors க்கு 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` ஒரு அத்தியாவசிய, idiomatic Go சுবிசேஷம் **உறுதிப்படுத்தப்பட்ட சுத்தம்** க்கு — முறையாக பங்கு விடுப்பு அடுத்தாக வைக்கப்பட்டு அனைத்து திரும்பல் பாதைகளில் செயல்படுவதை உறுதிப்படுத்துகிறது (panics உட்பட), இது கோப்புகள், locks, மற்றும் இணைப்புகள் கசாப்பு தடுக்கிறது கூடுதல் நம்பகத்தன்மையுடன் manual சுத்தம் விட.

க்பல defers LIFO வரிசை புரிந்து கொள்வது முக்கியமான. `panic`/`recover` ஒரு விதிவிலக்கு போன்ற வழிமுறை வழங்குகின்றன, ஆனால் **முக்கியமான கொள்கை** என்பது Go உண்மையான விதிவிலக்கு, மீண்டும் பெற முடியாத சூழ்நிலைகளுக்கு அவற்றை সংரக்ষிக்கிறது — சாதாரண errors எப்போதும் மதிப்புகளாக திரும்பிய மற்றும் சரிபார்ப்பு வேண்டும்.

ปานிค/பुनरुत्थान பொது விதிவிலக்கு மையாக misusing idiomatic அல்ல மற்றும் விதிவிலக்கு அடிப்படையிலான மொழிகள் இருந்து வரும் developers ஒரு பொதுவான தவறு.

எப்போது உபயோகம் செய்ய `defer` (எப்போதும், சுத்தம்), `error` திரும்பல் (சாதாரண தோல்விகள்), மற்றும் `panic`/`recover` (அரியவை, விதிவிலக்கு, அல்லது எல்லைகளில்) என்பது சரியான, idiomatic Go எழுத்து மற்றும் அடிக்கடி பேட்டை விஷயம் அடிப்படை.