რა აკეთებს defer, panic და recover?

Question

Accepted Answer

ეს სამი საკეთო სიტყვა მართავს გად延ված შესრულებას და გამონაკლის სიტუაციებს. **`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). ეს არის იდიომატური გზა გასუფთავების უზრუნველსაყოფად: ფაილების დახურვა, mutexes-ის განბლოკვა, კავშირების დახურვა — განთავსებულია მიღებისთან მოახლოებით, რათა ვერ დაიზაბოთ.

## მრავალი defer-ი აკეთებს 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` ჩერდება ნორმალური ნაკადი და მოხსნის ზარის დასტას (მოშვებული ფუნქციების გაშვებით გზაზე), საბოლოოდ რომ ჩამტეხოს პროგრამა. ეს არის **პროგრამისტის შეცდომებისთვის / აღუდგომელი პირობებისთვის** (საზღვრებს გარეთ, nil დერეფერენცია, შეუძლებელი მდგომარეობები) — არა ჩვეულებრივი შეცდომებისთვის (ისინი იყენებენ დაბრუნებულ `error` მნიშვნელობებს).

## recover — დაიჭირეთ panic (მხოლოდ გადფერსიტებული ფუნქციის შიგნით)

```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-ის კონტროლში — მაგრამ **მუშაობს მხოლოდ გადფერსიტებული ფუნქციის შიგნით**. იგი გამოიყენება იშვიათად, მაგალითად ერთი რეკვესტის დამუშავებელი იმისთვის, რომ მთელი სერვერი არ ჩამტეხოს.

## ძირითადი პრინციპი: არ გამოიყენოთ 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 მახასიათებელი **გარანტირებული გასუფთავებისთვის** — რესურსის გამოთავისუფლება განთავსებულია მიღების მოახლოებით და უზრუნველყოფს, რომ ის აკეთებს ყველა დაბრუნების ბილიკებზე (პანიკიდან ჩათვლით), რაც ღიჭვებულ ფაილებს, ჩამკეტებს და კავშირებს კიდევ უფრო საიმედოდ თავიდან აცილებს, ვიდრე ხელი მოწოდებული გასუფთავება.

მისი LIFO თანმიმდევრობის გაგება ასევე მნიშვნელოვანია. `panic`/`recover` იძლევა გამონაკლის მსგავს მექანიზმს, მაგრამ **კრიტიკული პრინციპი** არის ის, რომ Go ინახავს მათ ნამდვილი გამონაკლის, აღუდგომელი სიტუაციებისთვის — ჩვეულებრივი შეცდომები ყოველთვის უნდა დაბრუნდეს მნიშვნელობებად და შემოწმდეს.

panic/recover-ის არასწორი გამოყენება, როგორც ზოგადი გამონაკლის დამუშავება, არის არა-იდიომატური და საერთო შეცდომა დეველოპერებისთვის, რომლებიც მოდიან გამონაკლის-ბაზირებული ენებიდან.

ის გაგება, თუ როდის გამოიყენოთ `defer` (ყოველთვის, გასუფთავებისთვის), `error` დაბრუნება (ნორმალური წარუმატებლობა), და `panic`/`recover` (იშვიათი, გამონაკლისი ან საზღვრებზე) არის ფუნდამენტური სწორი, იდიომატური Go-ის დაწერისთვის და ხშირი ინტერვიუს თემა.