Yaya Go ke sarrafa kurakuran a matsayin daraja?

Question

Accepted Answer

Go ba shi da **watsinta** don daidaitaccen kurakuran. A maimakon haka, kurakuran su ne **daraja** da aka dawo daga ayyuka (sau da yawa a matsayin damje dabam), kuma wasu da suke kiran su **duba shi a sarari**. Wannan yana sanya sarrafa kurakuran **gida, da iko, da wadanda ba zai yiwu sai in yi watsi daidai**— falsafa na Go.

## Me ya sa yana da mahalaci

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

Duban `if err != nil { ... }` ta bayyana akai-akai a Go — kowane aiki da ya yi rashin nasara ana bin shi da bambanta kurakura. Wannan taƙama ta san niyya: kurakuran suna daidai bayyana kuma ana sarrafa su a wurin kira.

## Haltar kurakuran

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

## Damje da bincika kurakuran

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

Damje (`%w`) yana karawa jiya kamar kurakuran suke tashiya sama, yayin da `errors.Is`/`errors.As` suka ba da dama in bince ko cire musamman kurakuran asali — sabuwar hanya ta sarrafa jerin kurakuran.

## Nau'i na kurakuran na jiya

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

## kurakuran 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 n'ima-kurakura-matsayin-daraja yana ɗaya daga mafi baƙin ra'ayi da tattantattun fasali, daidai gwargwadon watsitacce da bukatu.

Wadanda suke dawo da kurakuran a matsayin daraja waɗanda masu kira dole ne a duba shi a babaɓɓe (`if err != nil`), Go yana sanya sarrafa kurakuran **bayyana, gida, da wanda ba zai yiwu sai in yi watsi ba taba**— kika ga daidai inda kura gaida ta sarrafa, yana inganta abin dogaro a wurin kusan baƙi.

Sanin falsafar nan, `(result, error)` allon, damje kurakuran (`%w`) tare da `errors.Is`/`errors.As` don ƙarawa jiya da bincika jerin, nau'i na kurakuran na jiya, da rarrabewa tsakanin kurakuran (na jiya, ɗin samarwa) da panic (abubuwan da ba daidai ba, kurakuran masu shirya) sai a sani sosai— yana yaɗa a cikin kowane shirin Go kuma yana wakiltar magudanan juriya ga masu buni da ke zo daga watsitacce da bukatu.

Kuma a cikin jerin manyan bututuwan tattaunawa na Go.