లోపాలు: `ఇఫ్ ఎర్రర్ != nil` నమూనా

గోలో, లోపాలు విలువలు, మినహాయింపులు కాదు. చేయగల ఫంక్షన్ ఫెయిల్ దోషాన్ని చివరి విలువగా చూపుతుంది మరియు కాలర్ దాన్ని తనిఖీ చేస్తాడు స్పష్టంగా. ఇది స్పష్టమైనది, ఊహించదగినది, పరీక్షించడం సులభం - ధర కొంచెం ఎక్కువ వెర్బోసిటీ.

error ఇంటర్‌ఫేస్

error అనేది భాషలో నిర్మించబడిన చిన్న ఇంటర్‌ఫేస్:

type error interface {
    Error() string
}

Error() stringని అమలు చేసే ఏదైనా రకం error.

ప్రాథమిక నమూనా

v, err := operazione()
if err != nil {
    // gestisci o propaga
    return err
}
// usa v

మీరు దీన్ని వేలసార్లు చూస్తారు: ఇది ప్రతిదానికి ఇడియోమాటిక్ కోడ్ తప్పు కాల్. పునరావృతం గురించి అపరాధ భావన లేదు — ఇది ఒక లక్షణం, కాదు ఒక బగ్.

నిర్మాణ లోపాలు: errors.New మరియు fmt.Errorf

import (
    "errors"
    "fmt"
)

err1 := errors.New("file mancante")
err2 := fmt.Errorf("apertura %q fallita: permesso negato", path)

మీరు సందేశంలో వేరియబుల్‌లను చేర్చాలనుకున్నప్పుడు fmt.Errorf సరైనది.

%wతో చుట్టడం

అసలైనదాన్ని కోల్పోకుండా సందర్భాన్ని జోడించడంలో లోపాన్ని ప్రచారం చేయడానికి:

f, err := os.Open(path)
if err != nil {
    return fmt.Errorf("config: %w", err)
}

%w అసలు లోపాన్ని "రాప్" చేస్తుంది, దీనితో తర్వాత తిరిగి పొందవచ్చు errors.Is (సెంటినెల్స్‌కు సమానత్వం) లేదా errors.As (కాంక్రీట్ రకం కోసం):

if errors.Is(err, os.ErrNotExist) {
    // file inesistente, gestione speciale
}

సెంటినల్ లోపాలు

ఇవి వేరియబుల్స్‌గా ఎగుమతి చేయబడిన లోపాలు, errors.Isతో పోలిక కోసం ఉపయోగించబడ్డాయి:

var ErrNotFound = errors.New("non trovato")

func find(id int) (Item, error) {
    // ...
    return Item{}, ErrNotFound
}

// chiamante:
if errors.Is(err, ErrNotFound) { ... }

panic మరియు recover (ప్రివ్యూ)

panic గోలో ఉంది కానీ కోలుకోలేని లోపాల కోసం ప్రత్యేకించబడింది (ఉదా. బగ్‌లు, ఉల్లంఘించిన మార్పులేనివి), సాధారణ నియంత్రణ ప్రవాహం కోసం కాదు. మేము మరింత లోతుగా వెళ్తాము defer/recoverతో ఫంక్షన్ల మాడ్యూల్. ప్రస్తుతానికి: దీన్ని ఉపయోగించవద్దు స్థానంలో if err != nil నమూనా.

దీనిని ప్రయత్నించండి

v, err := f()
// poi?

రీక్యాప్

• error అనేది ఒక పద్ధతితో కూడిన ఇంటర్‌ఫేస్ Error() string.
• నియమానుగుణ నమూనా: v, err := f(); if err != nil { return err }.
• errors.New(msg) లేదా fmt.Errorf("ctx: %w", err)తో లోపాలను రూపొందించండి.
• చుట్టడం కోసం %wని మరియు చైన్‌ని తనిఖీ చేయడానికి errors.Is / errors.Asని ఉపయోగించండి.
• panic పునరుద్ధరించలేని లోపాల కోసం మాత్రమే, సాధారణ నియంత్రణ ప్రవాహం కోసం కాదు.