Go errors ਨੂੰ values ਵਜੋਂ ਕਿਵੇਂ handle ਕਰਦਾ ਹੈ?

Question

Accepted Answer

Go ਕੋਲ ordinary errors ਲਈ **ਕੋਈ exceptions ਨਹੀਂ** ਹੈ। ਇਸ ਦੀ ਬਜਾਏ, errors ਫੰਕਸ਼ਨਾਂ ਤੋਂ **values** ਦੇ ਤੌਰ ਤੇ return ਕੀਤੇ ਜਾਂਦੇ ਹਨ (ਆਮ ਤੌਰ ਤੇ ਆਖਰੀ return value ਦੇ ਤੌਰ ਤੇ), ਅਤੇ callers ਉਨ੍ਹਾਂ ਨੂੰ **ਸਪੱਸ਼ਟ ਤੌਰ ਤੇ check** ਕਰਦੇ ਹਨ। ਇਹ error handling ਨੂੰ visible, deliberate, ਅਤੇ ਚੁੱਪ ਰਹਿ ਕੇ ignore ਕਰਨਾ ਅਸੰਭਵ ਬਣਾਉਂਦਾ ਹੈ — ਇਹ Go ਦਾ ਇੱਕ defining philosophy ਹੈ।

## error type ਅਤੇ core pattern

```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 { ... }` check Go ਵਿੱਚ ਸਥਿਰ ਰੂਪ ਵਿੱਚ ਪ੍ਰਗਟ ਹੁੰਦਾ ਹੈ — ਹਰ ਇੱਕ fallible operation ਦਾ ਪਾਲਣ ਇੱਕ ਸਪੱਸ਼ਟ error check ਨਾਲ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਇਹ verbosity deliberate ਹੈ: errors ਹਮੇਸ਼ਾ visible ਹੁੰਦੇ ਹਨ ਅਤੇ call site ਤੇ handle ਕੀਤੇ ਜਾਂਦੇ ਹਨ।

## Errors ਬਣਾਉਣਾ

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

## Wrapping ਅਤੇ inspecting 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 ਨੂੰ propagate ਕਰਦੇ ਹੋਏ context ਜੋੜਦਾ ਹੈ, ਜਦੋਂ ਕਿ `errors.Is`/`errors.As` ਤੁਹਾਨੂੰ specific underlying errors ਨੂੰ check ਕਰਨ ਜਾਂ extract ਕਰਨ ਦਿੰਦੇ ਹਨ — error chains ਨੂੰ handle ਕਰਨ ਦਾ modern way।

## Custom 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 ਬਨਾਮ 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 approach ਇਸ ਦੀਆਂ ਸਭ ਤੋਂ defining ਅਤੇ debated characteristics ਵਿੱਚੋਂ ਇੱਕ ਹੈ, ਜੋ exception-based languages ਤੋਂ fundamentally ਵੱਖਰਾ ਹੈ।

Errors ਨੂੰ values ਦੇ ਤੌਰ ਤੇ return ਕਰ ਕੇ ਜਿਨ੍ਹਾਂ ਨੂੰ callers ਨੂੰ ਸਪੱਸ਼ਟ ਤੌਰ ਤੇ check ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ (`if err != nil`), Go error handling ਨੂੰ **visible, local, ਅਤੇ accidentally ignore ਕਰਨਾ ਅਸੰਭਵ** ਬਣਾਉਂਦਾ ਹੈ — ਤੁਸੀਂ ਬਿਲਕੁਲ ਦੇਖ ਸਕਦੇ ਹੋ ਕਿ ਹਰ ਇੱਕ error ਕਿੱਥੇ handle ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਜੋ verbosity ਦੀ ਕੀਮਤ ਤੇ reliability ਵਿੱਚ improvement ਲਿਆਉਂਦਾ ਹੈ।

ਇਸ philosophy ਨੂੰ ਸਮਝਣਾ, `(result, error)` pattern, error wrapping (`%w`) with `errors.Is`/`errors.As` context ਜੋੜਨ ਅਤੇ chains ਨੂੰ inspect ਕਰਨ ਲਈ, custom error types, ਅਤੇ errors (normal, recoverable) ਅਤੇ panic (exceptional, programmer errors) ਵਿੱਚ distinction absolutely essential ਹੈ — ਇਹ ਹਰ ਇੱਕ Go program ਵਿੱਚ permeate ਕਰਦਾ ਹੈ ਅਤੇ exception-based languages ਤੋਂ آ ਰਹੇ developers ਲਈ ਇੱਕ core mental shift ਨੂੰ represent ਕਰਦਾ ਹੈ।

ਇਹ most common Go interview topics ਵਿੱਚੋਂ ਵੀ ਸ਼ਾਮਲ ਹੈ।