Kaip Go tvarko klaidas kaip reikšmes?

Question

Accepted Answer

Go **neturi išimčių** įprastoms klaidoms. Vietoj to, klaidos yra **reikšmės**, grąžintos iš funkcijų (dažniausiai kaip paskutinė grąžinta reikšmė), ir kviesėjai jas **aiškiai tikrina**. Tai daro klaidų tvarką matomą, tyčią ir neįmanoma tyliai ignoruoti — tai apibrėžianti Go filosofija.

## Klaidos tipas ir pagrindinė schema

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

Patikrinimas `if err != nil { ... }` nuolat pasirodo Go — kiekviena nepavaldi operacija yra sekama aiškiu klaidos tikrinimu. Šis žodingumas yra tyčias: klaidos visada matomos ir tvarkos atliekama kvietimo vietoje.

## Klaidų sukūrimas

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

## Klaidų supakalavimas ir tikrinimas

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

Supakalavimas (`%w`) prideda kontekstą, kai klaidos sklinda aukštyn, o `errors.Is`/`errors.As` leidžia tikrinti arba išgauti konkrečias pagrindinės klaidos — šiuolaikinė klaidų grandinių tvarkymo būdas.

## Pasirinktini klaidos tipai

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

## Kodėl tai svarbu

Go klaidos-kaip-reikšmės metodas yra vienas iš labiausiai apibrėžiančių ir ginčijamų bruožų, iš esmės kitoks nei į išimtis pagrįsti darbai.

Grąžinant klaidas kaip reikšmes, kurias kviesėjai turi aiškiai patikrinti (`if err != nil`), Go daro klaidų tvarkymą **matomu, lokaliu ir neįmanoma netyčia ignoruoti** — matote tiksliai kur kiekviena klaida tvarkoma, pagerinant patikimumą žodingumo kaina.

Suprasti šią filosofiją, `(result, error)` šabloną, klaidų supakalavimą (`%w`) naudojant `errors.Is`/`errors.As` kontekstui pridėti ir grandinėms patikrinti, pasirinktinus klaidų tipus ir skirtumą tarp klaidų (normalios, atgaunamos) ir panic (išskirtinis, programuotojo klaida) yra visiškai būtina — tai yra visoje Go programoje ir reiškia pagrindinį minties poslinkį kūrėjams iš į išimtis pagrįstų kalbų.

Tai taip pat yra viena iš dažniausiai Go pokalbių temų.