Kaip Go tvarko klaidas kaip reikšmes?

Question

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

Klaidos tipas ir pagrindinė schema

Klaidų sukūrimas

Klaidų supakalavimas ir tikrinimas

Pasirinktini klaidos tipai

errors vs panic

Kodėl tai svarbu

Susiję klausimai