Kako Go obravnava napake kot vrednosti?

Question

Accepted Answer

Go ima **brez izjem** za običajne napake. Namesto tega so napake **vrednosti**, ki jih funkcije vrnejo (običajno kot zadnja vrnjena vrednost), in klicatelji jih **eksplicitno preverijo**. To naredi obravnavo napak vidno, namerno in nemogoče tiho prezreti — to je osrednja Go filozofija.

## Tip napake in osnovni vzorec

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

Preverka `if err != nil { ... }` se v Go pojavljuje stalno — vsaki operaciji, ki se lahko ne uspe, sledi eksplicitna preverjanja napake. Ta zgoščenost je namera: napake so vedno vidne in obravnavane na mestu klica.

## Ustvarjanje napak

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

## Obogatitvovanje in preverjanje napak

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

Obogatitvovanje (`%w`) doda kontekst, ko se napake širijo navzgor, medtem ko `errors.Is`/`errors.As` omogočita preverjanje ali pridobivanje določenih temeljnih napak — sodobni način za obravnavo verig napak.

## Po meri definirani tipi napak

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

## errors v primerjavi s panic

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

## Zakaj je to pomembno

Pristop Goja, kjer so napake vrednosti, je ena najbolj defining in razpravljanih značilnosti, temeljno drugačna od jezikov, temeljenih na izjemah.

Z vrnitvijo napak kot vrednosti, ki jih morajo klicatelji eksplicitno preveriti (`if err != nil`), Go naredi obravnavo napak **vidno, lokalno in nemogoče naključno prezreti** — natančno vidiš, kje se vsaka napaka obravnava, kar izboljša zanesljivost na račun zgoščenosti.

Razumevanje te filozofije, vzorca `(result, error)`, obogatitvovanja napak (`%w`) z `errors.Is`/`errors.As` za dodajanje konteksta in pregledovanje verig, po meri definirani tipi napak ter razlikovanje med napakami (normalne, se jih da obnoviti) in panic (izjemne, napake programerja) je popolnoma nujno — to prežema vsak Go program in predstavlja osrednjo duševno spremembo za razvijalce iz jezikov, temeljenih na izjemah.

To je tudi med najbolj pogostimi temami za Go intervjuje.