Bagaimanakah Go mengendalikan ralat sebagai nilai?

Question

Accepted Answer

Go **tidak mempunyai pengecualian** untuk ralat biasa. Sebaliknya, ralat adalah **nilai** yang dikembalikan daripada fungsi (biasanya sebagai nilai pulangan terakhir), dan pemanggil **memeriksa dengan jelas**. Ini menjadikan pengendalian ralat boleh dilihat, disengajakan, dan mustahil untuk diabaikan secara senyap — falsafah Go yang menentukan.

## Jenis ralat dan corak teras

```go
// `error` is a built-in interface: anything with an Error() string method
type error interface {
    Error() string
}

// functions return (result, error) — error is nil on success
func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, errors.New("division by zero")   // create an error
    }
    return a / b, nil    // nil = no error
}

// the ubiquitous calling pattern
result, err := divide(10, 0)
if err != nil {              // CHECK the error explicitly
    fmt.Println("error:", err)
    return
}
fmt.Println(result)
```

Pemeriksaan `if err != nil { ... }` sentiasa muncul dalam Go — setiap operasi yang boleh gagal diikuti oleh pemeriksaan ralat yang jelas. Keterangan lanjut ini adalah disengajakan: ralat sentiasa boleh dilihat dan ditangani di tapak panggilan.

## Mencipta ralat

```go
errors.New("something failed")                       // simple error
fmt.Errorf("failed to process %s: %w", name, err)    // formatted, with WRAPPING (%w)
```

## Membungkus dan memeriksa ralat

```go
// %w WRAPS an underlying error, preserving the chain
if err != nil {
    return fmt.Errorf("reading config: %w", err)   // adds context, keeps original
}

// unwrap and inspect with errors.Is / errors.As
if errors.Is(err, os.ErrNotExist) { ... }          // check for a specific error
var pathErr *os.PathError
if errors.As(err, &pathErr) { ... }                 // extract a specific error type
```

Membungkus (`%w`) menambah konteks semasa ralat merambat ke atas, manakala `errors.Is`/`errors.As` membenarkan anda memeriksa atau mengekstrak ralat asas tertentu — cara moden untuk mengendalikan rantai ralat.

## Jenis ralat tersuai

```go
type ValidationError struct {
    Field string
}
func (e *ValidationError) Error() string {           // implement the error interface
    return "invalid field: " + e.Field
}
return &ValidationError{Field: "email"}
```

## ralat vs panik

```text
error (values) → EXPECTED, recoverable conditions (file missing, bad input) — the norm
panic          → UNEXPECTED, programmer errors / unrecoverable (nil deref, out of bounds)
→ Use errors for normal failure handling; reserve panic for truly exceptional cases.
```

## Mengapa ia penting

Pendekatan ralat-sebagai-nilai Go adalah salah satu ciri paling menentukan dan kontroversi, secara asasnya berbeza daripada bahasa berasaskan pengecualian.

Dengan mengembalikan ralat sebagai nilai yang pemanggil mesti periksa dengan jelas (`if err != nil`), Go menjadikan pengendalian ralat **boleh dilihat, tempatan, dan mustahil untuk diabaikan secara tidak sengaja** — anda melihat dengan tepat di mana setiap ralat ditangani, meningkatkan kebolehpercayaan dengan mengorbankan keterangan.

Memahami falsafah ini, corak `(result, error)`, pembungkusan ralat (`%w`) dengan `errors.Is`/`errors.As` untuk menambah konteks dan memeriksa rantai, jenis ralat tersuai, dan perbezaan antara ralat (normal, boleh pulih) dan panik (luar biasa, ralat pengaturcara) adalah sangat penting — ia meresapi setiap program Go dan mewakili peralihan pemikiran asas bagi pemaju yang datang daripada bahasa berasaskan pengecualian.

Ia juga antara topik temu duga Go yang paling biasa.