परिचय

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

इस लेख में, हम जानेंगे कि गोलांग में कस्टम त्रुटियों को प्रभावी ढंग से कैसे बनाया और उपयोग किया जाए।

गो की अंतर्निहित त्रुटि प्रबंधन को समझना

गो में, त्रुटि प्रकार एक अंतर्निहित इंटरफ़ेस है जो इस तरह दिखता है:

type error interface {
    Error() string
}

कोई भी प्रकार जो स्ट्रिंग रिटर्न प्रकार के साथ त्रुटि() विधि लागू करता है, इस इंटरफ़ेस को संतुष्ट करता है और इसे एक त्रुटि माना जा सकता है। यह सरल लेकिन शक्तिशाली है क्योंकि यह आपको इस विधि को लागू करके कस्टम त्रुटि प्रकार बनाने की अनुमति देता है।

गो में बुनियादी त्रुटि प्रबंधन

यहां गो में बुनियादी त्रुटि प्रबंधन का एक त्वरित उदाहरण दिया गया है:

package main

import (
    "errors"
    "fmt"
)

func main() {
    err := doSomething()
    if err != nil {
        fmt.Println("Error:", err)
    }
}

func doSomething() error {
    return errors.New("something went wrong")
}

यह उदाहरण मूल त्रुटि बनाने के लिए error.New फ़ंक्शन का उपयोग करता है। हालाँकि यह साधारण मामलों के लिए उपयोगी है, लेकिन इसमें अधिक संदर्भ प्रदान करने या विभिन्न प्रकार की त्रुटियों के बीच अंतर करने की क्षमता का अभाव है।

कस्टम त्रुटियाँ क्यों बनाएँ?

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

गो में कस्टम त्रुटियाँ बनाना

गो में एक कस्टम त्रुटि बनाने के लिए, आप एक नए प्रकार को परिभाषित करते हैं जो त्रुटि() विधि को लागू करता है। आइए एक उदाहरण से चलते हैं।

उदाहरण 1: एक साधारण कस्टम त्रुटि

यहां बताया गया है कि आप एक साधारण कस्टम त्रुटि कैसे बना सकते हैं:

package main

import (
    "fmt"
)

type MyError struct {
    Code    int
    Message string
}

func (e *MyError) Error() string {
    return fmt.Sprintf("Code %d: %s", e.Code, e.Message)
}

func main() {
    err := doSomething()
    if err != nil {
        fmt.Println("Error:", err)
    }
}

func doSomething() error {
    return &MyError{
        Code:    404,
        Message: "Resource not found",
    }
}

इस उदाहरण में, MyError एक कस्टम त्रुटि प्रकार है जिसमें एक कोड और एक संदेश शामिल है। Error() विधि इन्हें एक स्ट्रिंग में स्वरूपित करती है, जिससे त्रुटि को प्रिंट करना या लॉग करना आसान हो जाता है।

उदाहरण 2: त्रुटियों के साथ त्रुटियों की जाँच करना कार्य है

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

package main

import (
    "errors"
    "fmt"
)

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

func main() {
    err := doSomething()
    if errors.Is(err, ErrNotFound) {
        fmt.Println("Error:", err)
    }
}

func doSomething() error {
    return ErrNotFound
}

हालांकि यह दृष्टिकोण सीधा है, कस्टम त्रुटि प्रकारों के साथ सेंटिनल मानों का संयोजन और भी अधिक शक्तिशाली हो सकता है, जिससे त्रुटि तुलना और समृद्ध त्रुटि डेटा दोनों की अनुमति मिलती है।

उदाहरण 3: अधिक संदर्भ के लिए त्रुटियों को लपेटना

गो 1.13 ने %w क्रिया के साथ fmt.Errorf फ़ंक्शन पेश किया, जो आपको त्रुटियों को लपेटने की अनुमति देता है, मूल त्रुटि को संरक्षित करते हुए अधिक संदर्भ जोड़ता है।

package main

import (
    "errors"
    "fmt"
)

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

func main() {
    err := doSomething()
    if err != nil {
        fmt.Println("Error:", err)
        if errors.Is(err, ErrNotFound) {
            fmt.Println("The resource was not found.")
        }
    }
}

func doSomething() error {
    err := fetchResource()
    if err != nil {
        return fmt.Errorf("failed to do something: %w", err)
    }
    return nil
}

func fetchResource() error {
    return ErrNotFound
}

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

उदाहरण 4: अनरैप() विधि से त्रुटियों को समृद्ध करना

गो अनरैप() विधि का उपयोग करके लपेटी गई त्रुटि को निकालने का एक तरीका भी प्रदान करता है। इस विधि को अपने कस्टम त्रुटि प्रकारों में लागू करके, आप त्रुटियों को और अधिक खोलने की अनुमति दे सकते हैं।

package main

import (
    "errors"
    "fmt"
)

type MyError struct {
    Code    int
    Message string
    Err     error
}

func (e *MyError) Error() string {
    return fmt.Sprintf("Code %d: %s", e.Code, e.Message)
}

func (e *MyError) Unwrap() error {
    return e.Err
}

func main() {
    err := doSomething()
    if err != nil {
        fmt.Println("Error:", err)
        if errors.Is(err, ErrNotFound) {
            fmt.Println("The resource was not found.")
        }
    }
}

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

func doSomething() error {
    err := fetchResource()
    if err != nil {
        return &MyError{
            Code:    500,
            Message: "Something went wrong",
            Err:     err,
        }
    }
    return nil
}

func fetchResource() error {
    return ErrNotFound
}

यहाँ, MyError में एक Unwrap() विधि है जो रैप्ड त्रुटि लौटाती है। यह अंतर्निहित त्रुटि के गहन निरीक्षण और प्रबंधन की अनुमति देता है।

उदाहरण 5: त्रुटियों को एरर से जांचना। फ़ंक्शन के रूप में

गो एरर के साथ त्रुटि निकालने का एक तरीका भी प्रदान करता है। विधि के रूप में। इस पद्धति को अपने कस्टम त्रुटि प्रकारों में लागू करके, आप त्रुटि प्रकार की जांच कर सकते हैं और कस्टम त्रुटि मान भी प्राप्त कर सकते हैं।

package main

import (
    "errors"
    "fmt"
)

type MyError struct {
    Code    int
    Message string
    Err     error
}

func (e *MyError) Error() string {
    return fmt.Sprintf("Code %d: %s: %v", e.Code, e.Message, e.Err)
}

func main() {
    err := doSomething()
    var mErr *MyError
    // another way to initialize custom error
    // mErr := &MyError{}
    if errors.As(err, &mErr) {
        fmt.Println("Error:", mErr)
    }
}

// doSomething attempts to fetch a resource and returns an error if it fails.
// If the error is ErrNotFound, it is wrapped in a MyError with a code of 500.
func doSomething() error {
    err := fetchResource()
    if err != nil {
        return &MyError{
            Code:    500,
            Message: "Something went wrong",
            Err:     err,
        }
    }
    return nil
}

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

func fetchResource() error {
    return ErrNotFound
}

गो में कस्टम त्रुटियों के लिए सर्वोत्तम अभ्यास

1. कस्टम त्रुटियों का संयम से उपयोग करें: कस्टम त्रुटियां शक्तिशाली हैं लेकिन जटिलता बढ़ा सकती हैं। जब वे महत्वपूर्ण लाभ प्रदान करते हैं, जैसे बेहतर त्रुटि वर्गीकरण या अतिरिक्त संदर्भ, तो उनका उपयोग करें।

2. रैपिंग और अनरैपिंग का लाभ उठाएं: अतिरिक्त संदर्भ के साथ त्रुटियों को लपेटना और बाद में उन्हें खोलना एक सर्वोत्तम अभ्यास है जो त्रुटि डिबगिंग को बढ़ाता है।

3. अपनी त्रुटि प्रकारों का दस्तावेजीकरण करें: सुनिश्चित करें कि कोई भी कस्टम त्रुटि अच्छी तरह से प्रलेखित है ताकि उनका उद्देश्य और उपयोग स्पष्ट हो।

4. तुलना के लिए त्रुटि मानों को प्राथमिकता दें: जब आपको त्रुटियों की तुलना करने की आवश्यकता हो, तो स्थिरता और स्पष्टता के लिए पूर्वनिर्धारित त्रुटि मान (प्रहरी त्रुटियां) का उपयोग करने पर विचार करें।

निष्कर्ष

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