Apa sing ditindakake defer, panic, lan recover?

Question

Accepted Answer

Telung keyword iki nangani eksekusi ditunda lan situasi luar biasa. **`defer`** njadwalake pembersihan, **`panic`** memicu kerusakan runtime (kanggo kasus sing tenan luar biasa), lan **`recover`** bisa nyekel panic kanggo nyegah program supaya ora ambruk.

## defer — njadwalake panggilan nalika fungsi bulik

```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` njadwalake panggilan fungsi kanggo dieksekusi nalika fungsi sekitering bulik — ora peduli carane bulik (bulik normal, kesalahan, utawa panic). Iki cara idiomatik kanggo mesthikan pembersihan: nutup berkas, mbukak muteks, nutup sambungan — diselehake tengen ing samping perolehan supaya sampeyan ora bisa lali.

## Akeh defer kalakson ing urutan 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 — kanggo situasi luar biasa, ora bisa dipulihake

```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` mungkasi alur normal lan mbukak lapis panggilan (minangka deferensial fungsi ing dalan), pungkasan e ambruk program. Iki kanggo **kesalahan pemrograman / kondisi ora bisa dipulihake** (metu saka wates, nil dereference, kaanan mustahil) — BUKAN kanggo kesalahan biasa (sing nggunakake nilai `error` bali).

## recover — nyekel panic (mung ing fungsi ditunda)

```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` entuk kontrol maneh goroutine sing panik — nanging **mung bisa gumana ing fungsi ditunda**. Iki digunakake arang, conto kanggo mungkasi siji pamratelomg ingkubasi saka ambruk server kabeh.

## Prinsip kunci: aja nggunakake panic/recover kanggo kesalahan normal

```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)
```

## Mengapa penting

`defer` minangka fitur Go sing penting, idiomatik kanggo **pembersihan terjamin** — menempatake rilis sumber tengen ing samping perolehan lan mesthikan iku laksan ing saben dalan bali (kaanane panic), sing nyegah sambaran berkas, gembok, lan sambungan luwih andal tinimbang pembersihan manual.

Ngerti urutan LIFO-ne uga penting. `panic`/`recover` nyediake mekanisme mirip pengecualian, nanging **prinsip penting** yaiku Go nyisihake kanggo situasi luar biasa sing benere ora bisa dipulihake — kesalahan normal kudu kasil bali minangka nilai lan dieksamen.

Misgunakake panic/recover minangka penanganan pengecualian umum ora idiomatik lan kesalahan umum kanggo pangembang saka basa dhasar pengecualian.

Ngerti nalika nggunakake `defer` (tansah, kanggo pembersihan), pengembalian `error` (kegagalan normal), lan `panic`/`recover` (arang, luar biasa, utawa ing wates) minangka fondasi kanggo nulis Go sing bener, idiomatik lan topik wawancara sing asring ditakokake.