बेस्ट प्रैक्टिसेज जाओ - हैंडलिंग में त्रुटि

पाठों की एक श्रृंखला में यह पहला लेख है जिसे मैंने उत्पादन में गो के साथ काम करने वाले कुछ वर्षों में सीखा है। हम साल्टसाइड टेक्नोलॉजीज (पीएसटी, मैं बैंगलोर में कई पदों के लिए भर्ती कर रहा हूं) में उत्पादन में गो सेवाओं की एक अच्छी संख्या चला रहे हैं) और मैं अपना खुद का व्यवसाय भी चला रहा हूं जहां गो एक अभिन्न अंग है।

हम बड़े और छोटे विषयों की एक विस्तृत श्रृंखला को कवर करेंगे।

इस श्रृंखला में पहला विषय जो मैं कवर करना चाहता था वह है एरर हैंडलिंग। यह अक्सर नए गो डेवलपर्स के लिए भ्रम और झुंझलाहट का कारण बनता है।

कुछ पृष्ठभूमि - त्रुटि इंटरफ़ेस

बस इसलिए हम एक ही पृष्ठ पर हैं। जैसा कि आप जान सकते हैं कि गो में एक त्रुटि केवल कुछ है जो त्रुटि इंटरफ़ेस को लागू करता है। यह इंटरफ़ेस परिभाषा कैसी दिखती है:

टाइप एरर इंटरफेस {
    त्रुटि () स्ट्रिंग
}

तो कुछ भी जो त्रुटि () स्ट्रिंग विधि को लागू करता है उसे त्रुटि के रूप में उपयोग किया जा सकता है।

त्रुटियों के लिए जाँच की जा रही है

त्रुटि संरचनाओं और प्रकार की जाँच का उपयोग करना

जब मैंने लिखना शुरू किया तब मैंने अक्सर त्रुटि संदेशों की स्ट्रिंग तुलना की थी कि यह देखने के लिए कि त्रुटि प्रकार क्या था (हाँ, सोचने के लिए शर्मनाक लेकिन कभी-कभी आपको आगे जाने के लिए वापस देखने की आवश्यकता होती है)।

एक बेहतर तरीका त्रुटि प्रकारों का उपयोग करना है। तो आप (निश्चित रूप से) ऐसे स्ट्रक्चर्स बना सकते हैं जो एरर इंटरफेस को लागू करते हैं और फिर एक स्विच स्टेटमेंट में टाइप तुलना करते हैं।

यहां एक उदाहरण त्रुटि कार्यान्वयन है।

ErrZeroDivision संरचना टाइप करें {
    संदेश स्ट्रिंग
}
func NewErrZeroDivision (संदेश स्ट्रिंग) * ErrZeroDivision {
    वापसी और ErrZeroDivision {
        संदेश: संदेश,
    }
}
func (e * ErrZeroDivision) त्रुटि () स्ट्रिंग {
    वापसी
}

अब इस त्रुटि का उपयोग इस तरह किया जा सकता है।

दुर्गंध मुख्य () {
    परिणाम, गलत: = विभाजित (1.0, 0.0)
    अगर गलत है! = nil {
        इरेट करें (टाइप करें) {
        मामला * ErrZeroDivision:
            fmt.Println (err.Error ())
        चूक:
            fmt.Println ("क्या ह * बस हुआ?"
        }
    }
    fmt.Println (परिणाम)
}
func divide (ए, बी फ्लोट64) (फ्लोट64, त्रुटि) {
    अगर b == 0.0 {
        0.0 लौटें, NewErrZeroDivision ("शून्य से भाग नहीं कर सकता")
    }
    a / b, nil वापस करें
}

पूर्ण उदाहरण के लिए यहां जाएं प्ले लिंक है। स्विच इरेट को नोटिस करें। (टाइप) पैटर्न, जो किसी अन्य चीज़ (जैसे स्ट्रिंग तुलना या कुछ समान) के बजाय विभिन्न त्रुटि प्रकारों के लिए जाँच करना संभव बनाता है।

त्रुटियों के पैकेज और प्रत्यक्ष तुलना का उपयोग करना

उपरोक्त दृष्टिकोण को वैकल्पिक रूप से त्रुटियों के पैकेज का उपयोग करके नियंत्रित किया जा सकता है। यह दृष्टिकोण पैकेज के भीतर त्रुटि जांच के लिए अनुशंसित है जहां आपको त्वरित त्रुटि प्रतिनिधित्व की आवश्यकता होती है।

var irNotFound = त्रुटियाँ। नया ("आइटम नहीं मिला")
दुर्गंध मुख्य () {
    ग़लती: = getItem (123) // यह ग़लती से फेंक देगा
    अगर गलत है! = nil {
        पीछे हटो {
        मामला त्रुटिपूर्ण:
            log.Println ("आवश्यक आइटम नहीं मिला")
        चूक:
            log.Println ("अज्ञात त्रुटि हुई")
        }
    }
}

जब आप अधिक जटिल त्रुटि वाले ऑब्जेक्ट की आवश्यकता करते हैं, तो यह दृष्टिकोण कम अच्छा होता है। त्रुटि कोड आदि उस स्थिति में आपको अपना स्वयं का प्रकार बनाना चाहिए जो त्रुटि इंटरफ़ेस को लागू करता है।

तत्काल त्रुटि से निपटने

कभी-कभी मैं नीचे दिए गए कोड की तरह आता हूं (लेकिन आमतौर पर अधिक फुलाना के साथ ..):

func example1 () त्रुटि {
    ग़लती से: = call1 ()
    गलती से लौटना
}

यहाँ मुद्दा यह है कि गलत को तुरंत संभाला नहीं जाता है। यह एक नाजुक दृष्टिकोण है क्योंकि कोई गलत: = call1 () और रिटर्न के बीच कोड सम्मिलित कर सकता है, जो इरादे को तोड़ देगा, क्योंकि यह पहली त्रुटि हो सकती है। दो वैकल्पिक दृष्टिकोण:

// वापसी और त्रुटि को संक्षिप्त करें।
func example2 () त्रुटि {
    वापसी call1 ()
}
// कॉल के ठीक बाद स्पष्ट त्रुटि को हैंडल करें।
func example3 () त्रुटि {
    ग़लती से: = call1 ()
    अगर गलत है! = nil {
        गलती से लौटना
    }
    वापसी
}

उपरोक्त दोनों दृष्टिकोण मेरे साथ ठीक हैं। वे वही प्राप्त करते हैं, जो है; अगर किसी को call1 () के बाद कुछ जोड़ने की आवश्यकता है, तो उन्हें त्रुटि से निपटने की देखभाल करने की आवश्यकता है।

आज के लिए इतना ही

गो बेस्ट प्रैक्टिस के बारे में अगले लेख के लिए बने रहें। मजबूत जाओ :)।

दुर्गंध मुख्य () {
    ग़लती: = readArticle ("सर्वश्रेष्ठ व्यवहार पर जाएं - त्रुटि से निपटने")
    अगर गलत है! = nil {
        पिंग ( "@ sebdah")
    }
}