மொழியியல் பிழை கையாளுதல்

Go இல் கையாளுவதில் பிழை வெளிப்படையானது: விதிவிலக்குகள் இல்லை, முயற்சி/பிடிக்க முடியாது. தோல்வியடையும் ஒவ்வொரு செயல்பாடும் error ஐ அதன் கடைசி மதிப்பாக வழங்குகிறது, மேலும் அழைப்பவர் முடிவு செய்வார். இந்த அத்தியாயம் பிழைகளை உருவாக்குவதற்கும், பரப்புவதற்கும், மற்றும் ஆய்வு செய்வதற்கும், வலுவான விதத்தில் பேசும் வடிவங்களை சேகரிக்கிறது.

தங்க விதி

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

நான்கு கொள்கைகள்:

1. error என்பது கடைசி வருவாய்.
2. உடனடியாகச் சரிபார்க்கவும் if err != nil.
3. (fmt.Errorf + %w உடன்) பரப்புவதற்கு முன் சூழலைச் சேர்க்கவும்.
4. ஒருபோதும் புறக்கணிக்காதீர்கள் ஒரு பிழை: அதைக் கையாளவும், பதிவு செய்யவும் அல்லது திருப்பி அனுப்பவும்.

_ = file.Close() // EXPLICITLY ignored (you know what you're doing)

சென்டினல் பிழைகள்

சென்டினல் பிழை என்பது ஏற்றுமதி செய்யப்பட்ட உலகளாவிய மாறி var ErrXxx = errors.New("...") ஆகும், இதை அழைப்பவர் ஒப்பிடலாம்:

package store

var ErrNotFound = errors.New("not found")

func Get(key string) (string, error) {
    if !exists(key) {
        return "", ErrNotFound
    }
    // ...
}

அழைப்பாளர் errors.Is (== அல்ல) பயன்படுத்துகிறார், இது மடக்கு சங்கிலியை நடத்துகிறது:

v, err := store.Get(k)
if errors.Is(err, store.ErrNotFound) {
    // handle 404
}

நிலையான எடுத்துக்காட்டுகள்: io.EOF, sql.ErrNoRows, os.ErrNotExist.

தனிப்பயன் தட்டச்சு பிழைகள்

கட்டமைக்கப்பட்ட தரவை (HTTP குறியீடு, தவறான புலம் போன்றவை) எடுத்துச் செல்ல, ஒரு வகையை வரையறுக்கவும்:

type ValidationError struct {
    Field string
    Msg   string
}

func (e *ValidationError) Error() string {
    return fmt.Sprintf("%s: %s", e.Field, e.Msg)
}

அழைப்பாளர் சங்கிலியில் பாதுகாப்பாக இறக்குவதற்கு errors.As ஐப் பயன்படுத்துகிறார்:

var ve *ValidationError
if errors.As(err, &ve) {
    fmt.Println("invalid field:", ve.Field)
}

errors.As Unwrap() சங்கிலியைக் கடந்து செல்லும் சுட்டிக்கு ஒதுக்கக்கூடிய பிழையைக் கண்டறியும் வரை அது நடக்கும்.

%w உடன் ரேப்பிங்

fmt.Errorf %w வினைச்சொல்லுடன் பிழையை உருவாக்குகிறது, இது அசல் ஒன்றை முடக்கும் errors.Is/errors.As க்கு பாதுகாக்கிறது:

if err := db.Query(); err != nil {
    return fmt.Errorf("load users: %w", err)
}

%w இல்லாமல் (%v அல்லது %s ஐப் பயன்படுத்தி) நீங்கள் சிறந்த சரத்தைப் பெறுவீர்கள், ஆனால் இழக்கும் சங்கிலி: அழைப்பாளரால் குறிப்பிட்ட பிழைகளை இனி அடையாளம் காண முடியாது.

%w க்கான விதிகள்:

• fmt.Errorf அழைப்புக்கு ஒன்று மட்டுமே (மல்டி-ரேப் தேவை errors.Join).
• வாதமானது error ஆக இருக்க வேண்டும், சரம் அல்ல.
• சூழல் சேர், அசல் செய்தியை நகலெடுக்க வேண்டாம்.

// bad: duplicates
return fmt.Errorf("error: %w", err) // "error: file not found"

// good: useful context
return fmt.Errorf("load config %s: %w", path, err)

பல பிழைகளுக்கு errors.Join

கோ 1.20 முதல், errors.Join(errs...) பல பிழைகளை ஒருங்கிணைத்து errors.Is/As ஆல் கண்டறியக்கூடியதாக இருக்கும்:

var errs []error
for _, item := range items {
    if err := process(item); err != nil {
        errs = append(errs, fmt.Errorf("item %s: %w", item.ID, err))
    }
}
if len(errs) > 0 {
    return errors.Join(errs...)
}

எப்போது பயன்படுத்த வேண்டும் panic

எதிர்பார்க்கப்படும் பிழைகளுக்கு ஒருபோதும் இல்லை. மட்டும் மூன்று சந்தர்ப்பங்களில்:

1. மீட்க முடியாத பிழை: "நடக்க முடியாத" (panic("unreachable")) ஒரு இடத்தில் மாறாதது மீறப்பட்டது.
2. ஒரு தனி நிரலின் init()/main() இல் தோல்வியான துவக்கம் (முக்கியமான உள்ளமைவைக் காணவில்லை → வேகமாக தோல்வியடைகிறது).
3. லைப்ரரி ஏபிஐ அதை வெளிப்படையாக ஆவணப்படுத்துகிறது: எ.கா., regexp.MustCompile (முறை தவறானதாக இருந்தால் பீதி அடையும் — வடிவமானது உருவாக்க நேர மாறிலியாக இருப்பதால் ஏற்கத்தக்கது).

மற்ற அனைத்தும் error. *அப் பிரச்சாரம் செய்ய panic ஐ குறுக்குவழியாகப் பயன்படுத்த வேண்டாம்

பயிற்சிகள்

func F(x int) {
  // ??? panic(...)
}