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

## त्रुटी बनाम घबराहट

```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` सह संदर्भ जोडण्यासाठी आणि साखळी तपासण्यासाठी, कस्टम त्रुटी प्रकार आणि त्रुटी (सामान्य, पुनःप्राप्त करण्यायोग्य) आणि घबराहट (असाधारण, प्रोग्रामरची त्रुटी) मधील फरक समजणे पूर्णपणे आवश्यक आहे — हे प्रत्येक Go प्रोग्रामला व्याप्त करते आणि अपवाद-आधारित भाषांपासून येणार्‍या विकासकर्तांसाठी मुख्य मानसिक बदल दर्शवते.

हे Go मुलाखत विषयांपैकी सर्वात सामान्य आहे.