Go કેવી રીતે ભૂલોને મૂલ્યો તરીકે સંભાળે છે?

Question

Accepted Answer

Go માં સામાન્ય ભૂલો માટે **કોઈ અપવાદો નથી**. તેના બદલે, ભૂલો ફંક્શનમાંથી પરત કરવામાં આવતા **મૂલ્યો** છે (સામાન્યતઃ છેલ્લો રીટર્ન મૂલ્ય તરીકે), અને કૉલર્સ તેમને **સ્પષ્ટપણે ચકાસે** છે. આ ભૂલ સંચાલનને દૃશ્યમાન, ઉદ્દેશ્યપૂર્ણ અને સુંપુર્ણપણે અવગણવા માટે અસંભવ બનાવે છે — Go ફિલોસોફી.

## શા માટે તે મહત્વપૂર્ણ છે

```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 માં સતત દેખાય છે — દરેક નિષ્ફળ ઓપરેશન પછી સ્પષ્ટ ભૂલ ચેક આવે છે. આ વર્બોસિટી ઉદ્દેશ્યપૂર્ણ છે: ભૂલો હંમેશા દૃશ્યમાન છે અને કૉલ સાઇટ પર સંભાળવામાં આવે છે.

## ભૂલો બનાવવી

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

## ભૂલોને મૂળવણવું અને નિરીક્ષણ કરવું

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

મૂળવણ (`%w`) ભૂલો ઉપર ફેલાતી વખતે સંદર્ભ ઉમેરે છે, જ્યારે `errors.Is`/`errors.As` તમને ચોક્કસ અંતર્ગત ભૂલોને ચેક કરવા અથવા બહાર કાઢવા દે છે — ભૂલ શૃંખલાઓ હેન્ડલ કરવાનો આધુનિક રીત.

## કસ્ટમ ભૂલ પ્રકારો

```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 નો ભૂલ-તરીકે-મૂલ્ય અભિગમ તેના સૌથી વ્યાખ્યાયિત અને વિવાદાસ્પદ લક્ષણોમાંથી એક છે, અપવાદ-આધારિત ભાષાઓથી આધારિત રીતે અલગ છે.

જ્યારે કૉલર્સ સ્પષ્ટપણે ચેક કરવા જોઈએ તેવા મૂલ્યો તરીકે ભૂલો પરત કરી (`if err != nil`), Go ભૂલ સંચાલનને **દૃશ્યમાન, સ્થાનિક અને આકસ્મિક રીતે અવગણવા માટે અસંભવ** બનાવે છે — તમે જોશો કે દરેક ભૂલ ક્યાં હેન્ડલ કરવામાં આવી છે, નির્ભરતા સુધારીને વર્બોસિટીની કિંમત પર.

આ ફિલોસોફી, `(result, error)` પેટર્ન, ભૂલ મૂળવણ (`%w`) `errors.Is`/`errors.As` સાથે સંદર્ભ ઉમેરવા અને શૃંખલાઓ નિરીક્ષણ કરવા માટે, કસ્ટમ ભૂલ પ્રકારો, અને ભૂલો (સામાન્ય, પુનઃપ્રાપ્ય) અને panic (અપવાદી, પ્રોગ્રામર ભૂલો) વચ્ચેનો તફાવત સમજવો એ સંપૂર્ણપણે આવશ્યક છે — તે દરેક Go પ્રોગ્રામમાં વ્યાપ્ત છે અને અપવાદ-આધારિત ભાષાઓમાંથી આવતા ડેવલપર્સ માટે મૂળ માનસિક પરિવર્તન પ્રતિનિધિત્વ કરે છે.

તે Go ઇન્ટરવ્યુ વિષયોમાંથી સૌથી સામાન્ય પણ છે.