Go errors విలువలను ఎలా నిర్వహిస్తుంది?

Question

Accepted Answer

Go కు **అసాధారణ errors కోసం exceptions లేవు**. బదులుగా, errors ఫంక్షన్‌ల నుండి **రిటర్న్ చేయబడిన విలువలు** (సాధారణంగా చివరిగా రిటర్న్ చేయబడిన విలువ), మరియు కాలర్‌లు **స్పష్టంగా చెక్ చేస్తారు**. ఇది error handling ను కనిపించేలా, ఆలోచనాపూర్వకంగా, మరియు నిశ్శబ్దంగా విస్మరించడానికి అసాధ్యం చేస్తుంది — ఇది ప్రతిపాదిత Go తత్త్వశాస్త్రం.

## error type మరియు కోర్ నమూనా

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

`if err != nil { ... }` చెక్ Go లో నిరంతరం కనిపిస్తుంది — ప్రతి విఫల ఆపరేషన్ తర్వాత స్పష్టమైన error చెక్ ఉండిపోతుంది. ఈ వర్బోసిటీ ఉద్దేశ్యపూర్వకమైనది: errors ఎల్లప్పుడూ కనిపిస్తాయి మరియు కాల్ సైట్ వద్ద నిర్వహించబడతాయి.

## Errors సృష్టించడం

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

## Errors నుండి వైపు మరియు రీడ్ చేయడం

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

Wrapping (`%w`) errors ఎగువకు వ్యాపించినప్పుడు సందర్భాన్ని జోడిస్తుంది, అయితే `errors.Is`/`errors.As` నిర్దిష్ట అంతర్లీన errors కోసం చెక్ చేయడానికి లేదా సంగ్రహించడానికి అనుమతిస్తుంది — error chains నిర్వహించడానికి ఆధునిక మార్గం.

## అనుకూల error types

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

## ఎందుకు ఇది ముఖ్యమైనది

Go యొక్క error-as-value విధానం దీని అత్యంత నిర్వచిక మరియు చర్చనీయ లక్షణాలలో ఒకటి, exception-ఆధారిత భాషల నుండి ఆధారభూతంగా భిన్నంగా ఉంది.

Errors విలువలుగా రిటర్న్ చేయడం ద్వారా కాలర్‌లు స్పష్టంగా చెక్ చేయవలసి ఉంటుంది (`if err != nil`), Go error handling ను **కనిపించేలా, స్థానిక, మరియు ప్రతিఘటనగా విస్మరించడానికి అసాధ్యం** చేస్తుంది — ప్రతి error ఎక్కడ నిర్వహించబడుతుందో మీరు ఖచ్చితంగా చూస్తారు, విశ్వసనీయతను మెరుగుపరుస్తుంది verbosity ఖర్చుపై.

ఈ తత్త్వశాస్త్రం, `(result, error)` నమూనా, error wrapping (`%w`) `errors.Is`/`errors.As` సાથે సందర్భాన్ని జోడించడం మరియు chains ను రీడ్ చేయడం, అనుకూల error types, మరియు errors (సాధారణ, పునరుద్ధరణీయ) మరియు panic (అసాధారణ, ప్రోగ్రామర్ errors) మధ్య వ్యత్యాసం అర్థం చేసుకోవడం సంపూర్ణంగా అవసరం — ఇది ప్రతి Go ప్రోగ్రామ్‌ను విస్తరించింది మరియు exception-ఆధారిత భాషల నుండి వచ్చిన డెవలపర్‌ల కోసం కోర్ మానసిక మార్పును సూచిస్తుంది.

ఇది కూడా సర్వసాధారణ Go ఇంటర్వ్యూ విషయాలలో ఒకటి.