Apakah fungsi defer, panic dan recover?

Question

Accepted Answer

Ketiga-tiga kata kunci ini mengendalikan pelaksanaan tertunda dan situasi luar biasa. **`defer`** menjadualkan pembersihan, **`panic`** mencetuskan kemalangan masa jalan (untuk kes yang benar-benar luar biasa), dan **`recover`** boleh menangkap panic untuk menghalang program daripada terhenti.

## defer — jadualkan panggilan untuk masa fungsi kembali

```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` menjadualkan panggilan fungsi untuk dilaksanakan apabila fungsi sekeliling kembali — tidak kira bagaimana ia kembali (kembali biasa, ralat, atau panic). Ia cara idiomatik untuk memastikan pembersihan: menutup fail, membuka kunci mutex, menutup sambungan — diletakkan betul-betul di sebelah pemerolehan supaya anda tidak boleh terlupa.

## Pelbagai defer dilaksanakan mengikut susunan 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 — untuk situasi yang benar-benar luar biasa dan tidak boleh dipulihkan

```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` menghentikan aliran biasa dan menyahgulung tindanan panggilan (melaksanakan fungsi tertunda sepanjang jalan), akhirnya menyebabkan program terhenti. Ia untuk **ralat pengaturcara / keadaan yang tidak boleh dipulihkan** (di luar sempadan, nyahrujukan nil, keadaan mustahil) — BUKAN untuk ralat biasa (itu menggunakan nilai `error` yang dipulangkan).

## recover — tangkap panic (hanya dalam fungsi tertunda)

```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` mendapatkan semula kawalan goroutine yang mengalami panic — tetapi **hanya berfungsi dalam fungsi tertunda**. Ia digunakan secara berhemah, contohnya untuk menghalang satu pengendali permintaan daripada meruntuhkan keseluruhan pelayan.

## Prinsip utama: jangan guna panic/recover untuk ralat biasa

```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 ia penting

`defer` ialah ciri Go yang penting dan idiomatik untuk **pembersihan terjamin** — meletakkan pelepasan sumber betul-betul di sebelah pemerolehan dan memastikan ia berjalan pada setiap laluan kembali (termasuk panic), yang menghalang fail, kunci, dan sambungan terbocor dengan jauh lebih boleh dipercayai berbanding pembersihan manual.

Memahami susunan LIFOnya juga penting. `panic`/`recover` menyediakan mekanisme seperti pengecualian, tetapi **prinsip kritikalnya** ialah Go menyimpannya untuk situasi yang benar-benar luar biasa dan tidak boleh dipulihkan — ralat biasa sentiasa harus dipulangkan sebagai nilai dan diperiksa.

Menyalahguna panic/recover sebagai pengendalian pengecualian umum adalah tidak idiomatik dan kesilapan biasa bagi pembangun yang datang daripada bahasa berasaskan pengecualian.

Mengetahui bila menggunakan `defer` (sentiasa, untuk pembersihan), pulangan `error` (kegagalan biasa), dan `panic`/`recover` (jarang, luar biasa, atau di sempadan) adalah asas untuk menulis Go yang betul dan idiomatik serta topik temu duga yang kerap.