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

त्रुटि

त्रुटि एक इंटरफ़ेस है। और गो में अधिकांश इंटरफेस की तरह, त्रुटि की परिभाषा छोटी और सरल है:

type error interface { Error() string } 

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

गो मानक पुस्तकालय में दो कार्य हैं जो त्रुटियों को बनाने के लिए आसानी से उपयोग किए जाते हैं। त्रुटियाँ। नया फ़ंक्शन सरल त्रुटियों को बनाने के लिए अच्छी तरह से अनुकूल है। Fmt.Errorf फ़ंक्शन मानक स्वरूपण के उपयोग की अनुमति देता है।

 err := errors.New("emit macho dwarf: elf header corrupted") const name, id = "bimmler", 17 err := fmt.Errorf("user %q (id %d) not found", name, id) 

आमतौर पर, त्रुटियों से निपटने के लिए त्रुटि प्रकार पर्याप्त होता है। लेकिन कभी-कभी एक त्रुटि के साथ अतिरिक्त जानकारी प्रसारित करना आवश्यक हो सकता है; ऐसे मामलों में, आप अपनी खुद की प्रकार की त्रुटि जोड़ सकते हैं।
एक अच्छा उदाहरण ओएस पैकेज से PathError का प्रकार है

 // PathError records an error and the operation and file path that caused it. type PathError struct { Op string Path string Err error } func (e *PathError) Error() string { return e.Op + " " + e.Path + ": " + e.Err.Error() } 

ऐसी त्रुटि के मूल्य में ऑपरेशन, पथ और त्रुटि शामिल होगी।

वे इस तरह से शुरू होते हैं:

 ... return nil, &PathError{"open", name, syscall.ENOENT} ... return nil, &PathError{"close", file.name, e} 

प्रसंस्करण का एक मानक रूप हो सकता है:

 _, err := os.Open("---") if err != nil{ fmt.Println(err) } // open ---: The system cannot find the file specified. 

लेकिन अगर अतिरिक्त जानकारी प्राप्त करने की आवश्यकता है, तो आप * os.PathError में त्रुटि अनपैक कर सकते हैं:

 _, err := os.Open("---") if pe, ok := err.(*os.PathError);ok{ fmt.Printf("Err: %s\n", pe.Err) fmt.Printf("Op: %s\n", pe.Op) fmt.Printf("Path: %s\n", pe.Path) } // Err: The system cannot find the file specified. // Op: open // Path: --- 

एक ही दृष्टिकोण लागू किया जा सकता है यदि फ़ंक्शन कई अलग-अलग प्रकार की त्रुटियों को वापस कर सकता है।
खेलने

कई प्रकार की त्रुटियों की घोषणा, प्रत्येक का अपना डेटा है:

 type ErrTimeout struct { Time time.Duration Err error } func (e *ErrTimeout) Error() string { return e.Time.String() + ": " + e.Err.Error() } type ErrPermission struct { Status string Err error } func (e *ErrPermission) Error() string { return e.Status + ": " + e.Err.Error() } 

एक फ़ंक्शन जो इन त्रुटियों को वापस कर सकता है:

 func proc(n int) error { if n <= 10 { return &ErrTimeout{Time: time.Second * 10, Err: errors.New("timeout error")} } else if n >= 10 { return &ErrPermission{Status: "access_denied", Err: errors.New("permission denied")} } return nil } 

टाइप कास्ट्स के माध्यम से हैंडलिंग में त्रुटि:

 func main(){ err := proc(11) if err != nil { switch e := err.(type) { case *ErrTimeout: fmt.Printf("Timeout: %s\n", e.Time.String()) fmt.Printf("Error: %s\n", e.Err) case *ErrPermission: fmt.Printf("Status: %s\n", e.Status) fmt.Printf("Error: %s\n", e.Err) default: fmt.Println("hm?") os.Exit(1) } } } 

इस घटना में कि त्रुटियों को विशेष गुणों की आवश्यकता नहीं है, पैकेज स्तर पर त्रुटियों को संग्रहीत करने के लिए चर बनाने के लिए गो में अच्छा अभ्यास है। एक उदाहरण io.EOF, io.ErrNoProgress, और इसी तरह की त्रुटियां हैं।

नीचे दिए गए उदाहरण में, हम पठन को बाधित करते हैं और जब त्रुटि io.EOF होती है तब हम एप्लिकेशन को चलाना जारी रखते हैं या हम किसी अन्य त्रुटि के लिए एप्लिकेशन को बंद कर देते हैं।

 func main(){ reader := strings.NewReader("hello world") p := make([]byte, 2) for { _, err := reader.Read(p) if err != nil{ if err == io.EOF { break } log.Fatal(err) } } } 

यह प्रभावी है क्योंकि त्रुटियाँ केवल एक बार उत्पन्न होती हैं और पुन: उपयोग की जाती हैं।

स्टैक ट्रेस

स्टैक कैप्चर के समय बुलाए गए कार्यों की सूची। स्टैक ट्रेसिंग आपको सिस्टम में क्या चल रहा है इसका एक बेहतर विचार प्राप्त करने में मदद करता है। लॉग्स में ट्रेस सहेजना डिबगिंग के समय गंभीरता से मदद कर सकता है।

गो में अक्सर इस जानकारी की कमी होती है, लेकिन सौभाग्य से गो में डंप होना मुश्किल नहीं है।

आप मानक आउटपुट पर ट्रेस का उत्पादन करने के लिए debug.PrintStack () का उपयोग कर सकते हैं:

 func main(){ foo() } func foo(){ bar() } func bar(){ debug.PrintStack() } 

परिणामस्वरूप, Stderr को निम्नलिखित जानकारी लिखी जाएगी:

 goroutine 1 [running]: runtime/debug.Stack(0x1, 0x7, 0xc04207ff78) .../Go/src/runtime/debug/stack.go:24 +0xae runtime/debug.PrintStack() .../Go/src/runtime/debug/stack.go:16 +0x29 main.bar() .../main.go:13 +0x27 main.foo() .../main.go:10 +0x27 main.main() .../main.go:6 +0x27 

debug.Stack () स्टैक डंप के साथ बाइट्स का एक टुकड़ा देता है, जिसे बाद में लॉग इन या कहीं और किया जा सकता है।

 b := debug.Stack() fmt.Printf("Trace:\n %s\n", b) 

अगर हम ऐसा करते हैं तो एक और बात है:

 go bar() 

तब हमें आउटपुट पर निम्न जानकारी मिलती है:

 main.bar() .../main.go:19 +0x2d created by main.foo .../main.go:14 +0x3c 

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

 func bar(){ buf := make([]byte, 1024) for { n := runtime.Stack(buf, true) if n < len(buf) { break } buf = make([]byte, 2*len(buf)) } fmt.Printf("Trace:\n %s\n", buf) } 

 Trace: goroutine 5 [running]: main.bar() .../main.go:21 +0xbc created by main.foo .../main.go:14 +0x3c goroutine 1 [sleep]: time.Sleep(0x77359400) .../Go/src/runtime/time.go:102 +0x17b main.foo() .../main.go:16 +0x49 main.main() .../main.go:10 +0x27 

इस जानकारी को त्रुटि में जोड़ें और इस प्रकार इसकी सूचना सामग्री को बढ़ाएँ।
उदाहरण के लिए, इस तरह:

 type ErrStack struct { StackTrace []byte Err error } func (e *ErrStack) Error() string { var buf bytes.Buffer fmt.Fprintf(&buf, "Error:\n %s\n", e.Err) fmt.Fprintf(&buf, "Trace:\n %s\n", e.StackTrace) return buf.String() } 

आप इस त्रुटि को बनाने के लिए एक फ़ंक्शन जोड़ सकते हैं:

 func NewErrStack(msg string) *ErrStack { buf := make([]byte, 1024) for { n := runtime.Stack(buf, true) if n < len(buf) { break } buf = make([]byte, 2*len(buf)) } return &ErrStack{StackTrace: buf, Err: errors.New(msg)} } 

तो आप पहले से ही इस के साथ काम कर सकते हैं:

 func main() { err := foo() if err != nil { fmt.Println(err) } } func foo() error{ return bar() } func bar() error{ err := NewErrStack("error") return err } 

 Error: error Trace: goroutine 1 [running]: main.NewErrStack(0x4c021f, 0x5, 0x4a92e0) .../main.go:41 +0xae main.bar(0xc04207ff38, 0xc04207ff78) .../main.go:24 +0x3d main.foo(0x0, 0x48ebff) .../main.go:21 +0x29 main.main() .../main.go:11 +0x29 

तदनुसार, त्रुटि और ट्रेस को विभाजित किया जा सकता है:

 func main(){ err := foo() if st, ok := err.(*ErrStack);ok{ fmt.Printf("Error:\n %s\n", st.Err) fmt.Printf("Trace:\n %s\n", st.StackTrace) } } 

और निश्चित रूप से पहले से ही तैयार समाधान है। उनमें से एक https://github.com/pkg/errors पैकेज है। यह आपको एक नई त्रुटि बनाने की अनुमति देता है, जिसमें पहले से ही ट्रेस स्टैक होगा, और आप मौजूदा त्रुटि के लिए ट्रेस और / या अतिरिक्त संदेश जोड़ सकते हैं। प्लस सुविधाजनक आउटपुट स्वरूपण।

 import ( "fmt" "github.com/pkg/errors" ) func main(){ err := foo() if err != nil { fmt.Printf("%+v", err) } } func foo() error{ err := bar() return errors.Wrap(err, "error2") } func bar() error{ return errors.New("error") } 

 error main.bar .../main.go:20 main.foo .../main.go:16 main.main .../main.go:9 runtime.main .../Go/src/runtime/proc.go:198 runtime.goexit .../Go/src/runtime/asm_amd64.s:2361 error2 main.foo .../main.go:17 main.main .../main.go:9 runtime.main .../Go/src/runtime/proc.go:198 runtime.goexit .../Go/src/runtime/asm_amd64.s:2361 

% v केवल संदेश प्रदर्शित करेगा

 error2: error 

घबराहट / उबरना

आतंक (उर्फ दुर्घटना, उर्फ ​​आतंक), एक नियम के रूप में, खराबी की उपस्थिति का संकेत देता है, जिसके कारण सिस्टम (या एक विशिष्ट सबसिस्टम) कार्य करना जारी नहीं रख सकता है। यदि घबराहट को कहा जाता है, गो रनटाइम स्टैक को देखता है, तो इसके लिए एक हैंडलर खोजने की कोशिश कर रहा है।

अप्रमाणित पैनिक एप्लीकेशन को समाप्त कर देता है। यह मौलिक रूप से उन्हें उन त्रुटियों से अलग करता है जो आपको खुद को संसाधित करने की अनुमति नहीं देते हैं।

पैनिक फंक्शन कॉल पर आप कोई भी तर्क पास कर सकते हैं।

 panic(v interface{}) 

यह उस प्रकार की गड़बड़ी से घबराने में सुविधाजनक है जो वसूली को सरल बनाता है और डिबगिंग में मदद करता है।

 panic(errors.New("error")) 

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

और अब रिकवरी फ़ंक्शन दुर्घटना के बारे में जानकारी प्राप्त करना और कॉल स्टैक के अनइंडिंग को रोकना संभव बनाता है।
एक विशिष्ट पैनिक कॉल और हैंडलर:

 func main(){ defer func() { if err := recover(); err != nil{ fmt.Printf("panic: %s", err) } }() foo() } func foo(){ panic(errors.New("error")) } 

यदि कोई घबराहट न हो तो रिटर्न इंटरफेस {} (जिसे हम घबराहट के लिए पास करते हैं) या शून्य करें।

आपातकालीन हैंडलिंग के एक और उदाहरण पर विचार करें। हमारे पास कुछ कार्य हैं जिनके लिए हम एक संसाधन के लिए स्थानांतरण करते हैं और जो सिद्धांत में, आतंक पैदा कर सकता है।

 func bar(f *os.File) { panic(errors.New("error")) } 

सबसे पहले, आपको हमेशा अंत में कुछ क्रियाएं करने की आवश्यकता हो सकती है, उदाहरण के लिए, संसाधनों की सफाई, हमारे मामले में, फ़ाइल को बंद करना।

दूसरे, इस तरह के फ़ंक्शन के गलत निष्पादन से पूरे कार्यक्रम की समाप्ति नहीं होनी चाहिए।

इस समस्या को हल, पुनर्प्राप्त और बंद करने के साथ हल किया जा सकता है:

 func foo()(err error) { file, _ := os.Open("file") defer func() { if r := recover(); r != nil { err = r.(error) //   ,   ,     // err := errors.New("trapped panic: %s (%T)", r, r) //     } file.Close() //   }() bar(file) return err } 

समापन हमें उपरोक्त घोषित चर की ओर मुड़ने की अनुमति देता है, इसके लिए हम फ़ाइल को बंद करने की गारंटी देते हैं और दुर्घटना की स्थिति में, इसमें से एक त्रुटि निकालते हैं और इसे सामान्य त्रुटि हैंडलिंग तंत्र को पास करते हैं।

ऐसी विपरीत परिस्थितियां होती हैं जब कुछ तर्कों के साथ एक फ़ंक्शन को हमेशा सही तरीके से काम करना चाहिए, और यदि ऐसा नहीं होता है, तो यह वास्तव में खराब हो जाता है।

ऐसे मामलों में, एक आवरण फ़ंक्शन जोड़ें जिसमें लक्ष्य फ़ंक्शन कहा जाता है, और एक त्रुटि के मामले में, आतंक कहा जाता है।

जाओ आमतौर पर उपसर्ग होना चाहिए :

 // MustCompile is like Compile but panics if the expression cannot be parsed. // It simplifies safe initialization of global variables holding compiled regular // expressions. func MustCompile(str string) *Regexp { regexp, error := Compile(str) if error != nil { panic(`regexp: Compile(` + quote(str) + `): ` + error.Error()) } return regexp } 

 // Must is a helper that wraps a call to a function returning (*Template, error) // and panics if the error is non-nil. It is intended for use in variable initializations // such as // var t = template.Must(template.New("name").Parse("html")) func Must(t *Template, err error) *Template { if err != nil { panic(err) } return t } 

यह घबराहट और गोरोइटिन से जुड़ी एक और बात याद रखने लायक है।

ऊपर जो चर्चा की गई थी, उसमें से कुछ अंश:

• प्रत्येक गोरेइन के लिए एक अलग स्टैक आवंटित किया जाता है।
• घबराहट को बुलाते समय, रिकवरी को स्टैक पर खोजा जाता है।
• मामले में जब ठीक नहीं पाया जाता है, तो पूरा आवेदन समाप्त हो जाता है।

मुख्य हैंडलर फू से आतंक को नहीं पकड़ेंगे और कार्यक्रम दुर्घटनाग्रस्त हो जाएगा:

 func main(){ defer func() { if err := recover(); err != nil{ fmt.Printf("panic: %s", err) } }() go foo() time.Sleep(time.Minute) } func foo(){ panic(errors.New("error")) } 

यह एक समस्या होगी यदि, उदाहरण के लिए, एक हैंडलर को सर्वर से कनेक्ट करने के लिए कहा जाता है। किसी भी हैंडलर में भगदड़ की स्थिति में, पूरा सर्वर निष्पादन को पूरा करेगा। और आप किसी कारण से इन कार्यों में दुर्घटनाओं से निपटने को नियंत्रित नहीं कर सकते।
एक साधारण मामले में, समाधान कुछ इस तरह दिख सकता है:

 type f func() func Def(fn f) { go func() { defer func() { if err := recover(); err != nil { log.Println("panic") } }() fn() }() } func main() { Def(foo) time.Sleep(time.Minute) } func foo() { panic(errors.New("error")) } 

संभाल / जांच

शायद भविष्य में हम त्रुटि से निपटने में बदलाव देखेंगे। आप उनसे लिंक पर परिचित हो सकते हैं:
go2draft
Go 2 में त्रुटि हैंडलिंग

आज के लिए बस इतना ही। धन्यवाद!