Go ले त्रुटिहरूलाई मानहरूको रूपमा कसरी सम्हाल्छ?

Question

Accepted Answer

Go मा साधारण त्रुटिहरूको लागि **कुनै अपवादहरू छैनन्**। यसको सट्टा, त्रुटिहरू **मानहरू** हुन् जो फंक्शनहरूबाट फर्काइन्छन् (सामान्यतः अन्तिम return मानको रूपमा), र कलरहरूले **स्पष्ट रूपमा जाँच** गर्छन्। यसले error handling दृश्यमान, जानबूझकर, र चुप्पीसँग उपेक्षा गर्न असम्भव बनाउँछ — यो Go को परिभाषित दर्शन हो।

## error type र मूल 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 { ... }` जाँच Go मा लगातार दिखिन्छ — प्रत्येक fallible operation लाई एक स्पष्ट error check द्वारा पछि गरिन्छ। यो冗長性जानबूझकर हो: त्रुटिहरू सधैं दृश्यमान हुन्छन् र call site मा सम्हालिन्छन्।

## त्रुटिहरू बनाउने

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

## त्रुटिहरूलाई wrap गर्ने र निरीक्षण गर्ने

```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`) context जोड्छ जब त्रुटिहरू माथि propagate हुन्छन्, जबकि `errors.Is`/`errors.As` ले तपाइंलाई विशिष्ट अन्तर्निहित त्रुटिहरूको लागि जाँच गर्न वा निकाल्न दिन्छ — 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-आधारित भाषाहरूबाट मौलिक रूपमा भिन्न।

त्रुटिहरूलाई मानहरू फर्काउँदा जो कलरहरूले स्पष्ट रूपमा जाँच गर्नु पर्छ (`if err != nil`), Go ले error handling लाई **दृश्यमान, स्थानीय, र दुर्घटनावश उपेक्षा गर्न असम्भव** बनाउँछ — तपाइं बिल्कुल देख्नुहुन्छ कि प्रत्येक त्रुटि कहाँ सम्हालिएको छ, verbosity को लागत मा विश्वसनीयता सुधार गर्दै।

यो दर्शन, `(result, error)` pattern, error wrapping (`%w`) context जोड्ने र chains निरीक्षण गर्ने `errors.Is`/`errors.As` सँग, custom error types, र त्रुटिहरू (सामान्य, recoverable) र panic (असाधारण, programmer त्रुटिहरू) बीचको भेद बुझ्न पूर्णतः आवश्यक छ — यो प्रत्येक Go प्रोग्रामलाई व्यापक गर्छ र exception-आधारित भाषाहरूबाट आउने developers को लागि मूल मानसिक परिवर्तन प्रतिनिधित्व गर्छ।

यो पनि सबैभन्दा सामान्य Go साक्षात्कार विषयहरू मध्ये एक हो।