Go hushughulikia vipi makosa kama thamani?

Question

Accepted Answer

Go **haina exceptions** kwa makosa ya kawaida. Badala yake, makosa ni **thamani** zinazorudishwa kutoka kwa functions (kwa kawaida kama thamani ya mwisho ya kurudisha), na waitaji **hukagua wazi**. Hii hufanya ushughulikiaji wa makosa kuwa dhahiri, wa makusudi, na usiowezekana kupuuzwa kimya — falsafa bainifu ya Go.

## Aina ya error na mfumo wa msingi

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

Ukaguzi wa `if err != nil { ... }` huonekana mara kwa mara katika Go — kila operesheni inayoweza kushindwa hufuatwa na ukaguzi wa kosa dhahiri. Urefu huu ni wa makusudi: makosa daima ni dhahiri na hushughulikiwa mahali pa wito.

## Kuunda makosa

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

## Kufunika na kukagua makosa

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

Kufunika (`%w`) huongeza muktadha kadiri makosa yanavyopanda juu, huku `errors.Is`/`errors.As` zikikuruhusu kukagua au kutoa makosa mahususi yaliyo chini — njia ya kisasa ya kushughulikia minyororo ya makosa.

## Aina maalum za makosa

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

## Kwa nini ni muhimu

Mbinu ya Go ya kosa-kama-thamani ni mojawapo ya sifa zake bainifu na zinazojadiliwa zaidi, tofauti kabisa na lugha zinazotegemea exceptions.

Kwa kurudisha makosa kama thamani ambazo waitaji lazima wakague wazi (`if err != nil`), Go hufanya ushughulikiaji wa makosa kuwa **dhahiri, wa kienyeji, na usiowezekana kupuuzwa kwa bahati mbaya** — unaona hasa pale kila kosa linaposhughulikiwa, kuboresha uaminifu kwa gharama ya urefu.

Kuelewa falsafa hii, mfumo wa `(result, error)`, kufunika makosa (`%w`) na `errors.Is`/`errors.As` kwa kuongeza muktadha na kukagua minyororo, aina maalum za makosa, na tofauti kati ya errors (kawaida, zinazoweza kurekebishwa) na panic (za kipekee, makosa ya mtayarishaji) ni muhimu kabisa — inaenea katika kila programu ya Go na huwakilisha mabadiliko ya kimsingi ya kifikra kwa wasanidi wanaotoka katika lugha zinazotegemea exceptions.

Pia ni mojawapo ya mada za kawaida zaidi za mahojiano ya Go.