Conas a bhaineann Go le hearracha mar luachanna?

Question

Accepted Answer

Níl **aon eisceachtaí** ag Go do ghnáth-earracha. Ina áit sin, is **luachanna** iad earracha a tharchuirtear ó fheidhmeanna (go hiondúil mar an dá luach dheireanach ar ais), agus **déanann glaochaidh conspóid ar an gceist go soiléir** orthu. Déanann sé seo an bhainistiú earracha **infheidhmithe, stuama, agus dodhéanta a ligint ar neamhaire go foluain** — fealsúnacht bhunúsach Go.

## Cén fáth a bhíonn tábhacht aici

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

Túirlingíonn an tseiceáil `if err != nil { ... }` go leanúnach i Go — leantar gach oibríocht dhochúlanta de sheiceáil earracha dhíreach. Tá an fhorbóireacht seo fúgthar ar intinn: bíonn earracha infheidhmithe i gcónaí agus bainistríonn siad ag an suíomh glaoch.

## Earracha a chruthú

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

## Earracha a dhúdhlúthú agus a dhíchealú

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

Cuireann dúdhlúthú (`%w`) comhthéacs leis agus a bhí earracha á scaipeadh suas, fad is a bhfuil `errors.Is`/`errors.As` i d'fhéachaint ar earracha fúnasacha ar leith a sheiceáil nó a bhaint — an bealach nua-aimseartha chun slabhraí earracha a bhainistiú.

## Cineálacha earracha saincheaptha

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

Is é an cur chuige Go ar earracha mar luachanna ina gceann de na tréithe is spéire agus díospóireachta aici, go bunúsach difriúil ó theangacha atá bunaithe ar eisceachtaí.

Trí earracha a thabhairt ar ais mar luachanna ar a gcaithfidh glaochaidh conspóid a dhéanamh ar an gceist go soiléir (`if err != nil`), déanann Go an bhainistiú earracha **infheidhmithe, áitiúil, agus dodhéanta a bheith ann ar neamhaire go tubaisteach** — feictear duit go díreach conas a bhainistítear gach earracha, ag feabhsú ar iontaobhais ar chostaí verbosity.

Bheith i bhfios ar an bhfealsúnacht seo, an patrún `(result, error)`, dúdhlúthú earracha (`%w`) le `errors.Is`/`errors.As` chun comhthéacs a chur leis agus slabhraí a scrúdú, cineálacha earracha saincheaptha, agus an deighilt idir earracha (gnáth, aisghabhála) agus panic (eisceachtúil, earracha cláraitheora) is gá ar an bhealach is mó — cuireann sé sin foluain i ngach clár Go agus ionadaíonn sé athrú intinne bunúsach do fhorbróirí ó theangacha atá bunaithe ar eisceachtaí.

Is é an cheist dheireanach ar na topaicí agallamh Go is choitianta.