Go குறிப்புகளை மூல்यங்களாக எவ்வாறு கையாளுகிறது?

Question

Accepted Answer

Go-வுக்கு சாধாரண குறிப்புகளுக்கு **விதிவிலக்குகள் இல்லை**. மாறாக, குறிப்புகள் சார்புகளிலிருந்து திரும்பிய **மூல்யங்கள்** (பொதுவாக கடைசி திரும்பிய மூல்யம்), மற்றும் அழைப்பாளர்கள் அவற்றை **வெளிப்படையாக சரிபார்க்கின்றனர்**. இது குறிப்பு கையாளுதலை தெரியும், ஆக்கபூர্வமாக, மற்றும் அமைதியாக புறக்கணிக்க முடியாதது — ஒரு வரையறுக்கப்பட்ட Go தத்துவம்.

## error வகை மற்றும் மূல கட்டமைப்பு

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

Mötтяватन (`%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 நேர்காணல் பொருள்களுள் ஒன்றும் ஆகும்.