లోపం ఇంటర్ఫేస్

error ఇన్ గో కీవర్డ్ కాదు: ఇది అంతర్నిర్మిత ఇంటర్‌ఫేస్ ఒకే పద్ధతి.

type error interface {
    Error() string
}

Error() stringని కలిగి ఉన్న ఏదైనా error. తో కలిపి ఫంక్షన్ల నుండి (T, error) తిరిగి వచ్చే సమావేశం, ఇది గోలో లోపం నిర్వహణ యొక్క పునాది.

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

import "errors"

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

func find(key string) (string, error) {
    // ...
    return "", ErrNotFound
}

ఒక సెంటినల్ అనేది కాలర్ చేయగల ఎగుమతి చేయబడిన error విలువ నిర్దిష్ట లోపం కేసును గుర్తించడానికి పోల్చండి.

అనుకూల లోపాలు (డేటాతో)

సందర్భాన్ని తీసుకువెళ్లడానికి (ఉదా. తప్పిపోయిన కీ) మీరు ఒక రకాన్ని నిర్వచించండి:

type ErrNotFound struct {
    Key string
}

func (e *ErrNotFound) Error() string {
    return "non trovato: " + e.Key
}

func find(key string) (string, error) {
    return "", &ErrNotFound{Key: key}
}

దోషాలు

==తో పోల్చడం "స్వచ్ఛమైన" సెంటినెల్స్‌కు మాత్రమే పని చేస్తుంది. దృఢంగా ఉండాలి ర్యాప్డ్ ఎర్రర్‌లకు వ్యతిరేకంగా, errors ప్యాకేజీని ఉపయోగించండి:

import "errors"

if errors.Is(err, ErrNotFound) {
    // err IS ErrNotFound (even if wrapped)
}

var nfe *ErrNotFound
if errors.As(err, &nfe) {
    // err IS (or wraps) an *ErrNotFound; nfe points to the concrete value
    fmt.Println("chiave mancante:", nfe.Key)
}

• errors.Is(err, target): ర్యాపింగ్ చైన్‌లో ఎక్కడైనా లక్ష్యం ఉంటే నిజం.
• errors.As(err, &target): దాని రకం గొలుసులోని మొదటి లోపాన్ని లక్ష్యం చేయడానికి కేటాయిస్తుంది.

%wతో చుట్టడం

if err := find("k"); err != nil {
    return fmt.Errorf("operazione X: %w", err)
}

%w (%s లేదా %v) రాప్ అనే కొత్త లోపాన్ని సృష్టిస్తుంది అసలైనది, errors.Is/As ద్వారా గొలుసును నావిగేబుల్‌గా ఉంచడం.

హ్యాండ్లింగ్ నమూనా

v, err := op()
if err != nil {
    return fmt.Errorf("op fallita per %q: %w", id, err)
}

ఇడియమ్స్:

• err != nil వెంటనేని తనిఖీ చేయండి, "ప్రారంభ సంతోషకరమైన మార్గం" లేదు.
• fmt.Errorf("... : %w", err)తో ప్రతి స్థాయిలో సందర్భాన్ని జోడించండి.
• "అప్‌స్ట్రీమ్" (ప్రధాన / హ్యాండ్లర్ దగ్గర), errors.Is/Asతో వివక్ష చూపండి.

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

func (e *MyErr) ??? {}

రీక్యాప్

• error = interface { Error() string }, అంతర్నిర్మిత.
• సందర్భం లేకుండా తెలిసిన కేసుల కోసం errors.New("...")తో సెంటినెల్స్.
• సందర్భాన్ని తీసుకెళ్లడానికి ఫీల్డ్‌లతో అనుకూల ఎర్రర్ రకాలు.
• errors.Is(err, target): చుట్టడానికి బలమైన పోలిక.
• errors.As(err, &target): కాంక్రీట్ రకం వెలికితీత.
• fmt.Errorf("...: %w", err): గొలుసును సంరక్షించే చుట్టడం.
• ఎప్పుడూ %v / %s చుట్టడానికి: ఎల్లప్పుడూ %wని ఉపయోగించండి.