Kako Go rukuje greškama kao vrijednostima?

Question

IT Interview Practice · Accepted Answer

Go **nema iznimki** za obične greške. Umjesto toga, greške su **vrijednosti** koje se vraćaju iz funkcija (obično kao posljednja povratna vrijednost), a pozivači ih **eksplicitno provjeravaju**. To čini rukovanje greškama **vidljivim, namjernim i nemogućim za nijemo ignorirati** — definiraća Go filozofija.

## Zašto je to važno

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

Provjera `if err != nil { ... }` se neprekidno pojavljuje u Go-u — nakon svakog neuspješnog rada dolazi eksplicitna provjera greške. Ova verboznost je namjerna: greške su uvijek vidljive i obrađene na mjestu poziva.

## Stvaranje grešaka

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

## Omotavanje i provjera grešaka

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

Omotavanje (`%w`) dodaje kontekst dok se greške šire prema gore, dok `errors.Is`/`errors.As` vam omogućuje provjeru ili izdvajanje specifičnih temeljnih grešaka — moderni način rukovanja lanacima grešaka.

## Prilagođeni tipovi grešaka

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

Go-ov pristup greškama kao vrijednostima je jedan od njegovih najjednostavnijih i najspornijih značajki, fundamentalno drugačiji od jezika temeljenih na iznimkama.

Na vraćanju grešaka kao vrijednosti koje pozivači moraju eksplicitno provjeriti (`if err != nil`), Go čini rukovanje greškama **vidljivim, lokalnim i nemogućim za slučajno ignorirati** — točno vidite gdje se svaka greška obrađuje, poboljšavajući pouzdanost po cijeni verboznosti.

Razumijevanje ove filozofije, obrasca `(result, error)`, omotavanja grešaka (`%w`) sa `errors.Is`/`errors.As` za dodavanje konteksta i provjeru lanaca, prilagođenih tipova grešaka i razlike između grešaka (normalne, oporavljivih) i panic (izvanrednih, greške programera) je potpuno neophodno — prožima svaki Go program i predstavlja temeljnu mentalnu promjenu za razvojne programere koji dolaze iz jezika temeljenih na iznimkama.

To je također među najčešćim Go temama u intervjuima.

Zašto je to važno

Stvaranje grešaka

Omotavanje i provjera grešaka

Prilagođeni tipovi grešaka

errors vs panic

Povezana pitanja