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

Question

IT Interview Practice · 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 ઇન્ટરવ્યુ વિષયોમાંથી સૌથી સામાન્ય પણ છે.

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

ભૂલો બનાવવી

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

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

errors vs panic

સંબંધિત પ્રશ્નો