Bagaimanakah Go mengendalikan ralat sebagai nilai?

Question

IT Interview Practice · 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.

Jenis ralat dan corak teras

Mencipta ralat

Membungkus dan memeriksa ralat

Jenis ralat tersuai

ralat vs panik

Mengapa ia penting

Soalan berkaitan