Perl6 - अपवाद हैंडलिंग

1. Perl6 में चर और शाब्दिक के साथ काम करने की विशेषताएं
2. पर्ल 6 - चर, अनाम ब्लॉकों पर संचालन
3. पर्ल 6 - सशर्त कथन, लूप
4. पर्ल 6 - कार्यों के साथ काम करें
5. पर्ल 6 - कक्षाएं
6. पर्ल 6 - आई / ओ मॉड्यूल
7. पर्ल 6 - टिप्पणियाँ, श्वेत स्थान, कोष्ठक
8. पर्ल 6 - ऑपरेटर ओवरलोडिंग
9. पर्ल 6 - डेटा प्रकारों के साथ काम करना
पिछले लेख में, मैंने अपवादों को पकड़ने का संकेत दिया था। अपवादों को पूरा करने वाली कुछ लिपियाँ बच गईं, और मेरी कई लिपियाँ उनकी उंगलियों पर मर गईं। शायद अब समय आ गया है कि उनके लिए शिकार की व्यवस्था की जाए। उन लोगों के लिए जो हमें उनके साथ पकड़ेंगे, हम एक कटौती के तहत मिलते हैं।


और इसलिए, हमारे पास निम्नलिखित कोड है:

sub Func($a) { my $temp = $a*2; } Func "Test"; 

जैसा कि आपने अनुमान लगाया होगा, "टेस्ट" लाइन से दशमलव संख्या प्राप्त करने का प्रयास करते समय हमें एक अपवाद मिलेगा।
एक अपवाद हैंडलर जोड़ने के लिए, हमें निम्नलिखित निर्माण जोड़ना होगा:

 sub Func($a) { my $temp = $a*2; say "Test work"; CATCH { default { say "Something is wrong!"; } } } Func "Test"; say "Another test work"; 

C ++ के विपरीत, छठे मोती में, अपवाद हैंडलिंग ब्लॉक को ब्लॉक के अंदर जोड़ा जाता है जहां अपवाद हो सकता है। इस प्रकार, इस स्क्रिप्ट को निष्पादित करते समय, हम आउटपुट प्राप्त करते हैं:

 Something is wrong! Another test work 

दूसरे शब्दों में, जिस खंड में अपवाद होता है वह अपना काम करना बंद कर देता है (और यह कहना थोड़ा गलत है, लेकिन हम इस बारे में बाद में बात करेंगे), और CATCH ब्लॉक काम करना शुरू कर देता है, जिसमें लाइन का आउटपुट कुछ गलत है। CATCH ब्लॉक को अंजाम देने के बाद, स्क्रिप्ट जारी रहती है और अगले कमांड के साथ उस ब्लॉक का अनुसरण करना शुरू कर देता है जिसमें अपवाद हुआ था। यही कारण है कि हम स्क्रीन पर शिलालेख "परीक्षण कार्य" नहीं देखते हैं।

वास्तव में, हमारा CATCH ब्लॉक एक नियमित "स्विच" है। और हम निम्नलिखित जोड़ सकते हैं:

 sub Func($a) { my $temp = $a*2; say "Test work"; CATCH { when X::Syntax::Name::Null { say "I will never say it =("; } default { say "Something is wrong! "~$_.WHAT.gist; } } } Func "Test"; say "Another test work"; 

हालाँकि, हमारे अपवाद का पाठ पढ़ता है, "मैं ऐसा कभी नहीं कहूंगा।" ऐसा इसलिए है क्योंकि हमारे मामले में, फ़ंक्शन ऐसी क्रियाएं नहीं करता है जिसमें यह अपवाद होता है। सभी समान, यह समझने के लिए कि मेरे पास क्या अपवाद है, मैंने "$_.WHAT.gist" जोड़ा। जब आप CATCH ब्लॉक में प्रवेश करते हैं, तो $ पकड़ा गया अपवाद ऑब्जेक्ट $ _ चर में दर्ज किया जाता है। फिर हम इसके प्रकार के ऑब्जेक्ट को लेते हैं और इसे लाइन में लाते हैं (डिबग के लिए .gist फ़ंक्शन, जो आपको ऑब्जेक्ट के अंदर देखने की अनुमति देता है, मैं यहां इसका वर्णन नहीं करूंगा)।
इस प्रकार, अब हम निम्नलिखित निष्कर्ष प्राप्त करते हैं:

 Something is wrong! (X::Str::Numeric) Another test work 

अब हम जानते हैं कि किस विशेष अपवाद को पकड़ा गया था। हम उनके नाम की नकल करते हैं और अपने अपवाद का विवरण देखने के लिए धर्मसभा में जाते हैं । ( यहां हमारे अपवाद के लिए एक सीधा लिंक है )। जिसके बाद हम एक और ब्लॉक जोड़ सकते हैं जब:

 sub Func($a) { my $temp = $a*2; say "Test work"; CATCH { when X::Syntax::Name::Null { say "I will never say it =("; } when X::Str::Numeric { say "String convertation error!"; } default { say "Something is wrong! "~$_.WHAT.gist; } } } Func "Test"; say "Another test work"; 

परिणामस्वरूप, हम निष्कर्ष देखेंगे:

 String convertation error! Another test work 

स्वाभाविक रूप से, हम वस्तु के सभी क्षेत्रों को चर $ _ के माध्यम से एक्सेस कर सकते हैं। अपवाद के विवरण में फ़ील्ड फिर से दिखते हैं।

-अब, कुछ मैं शिकार से थक गया हूँ, शायद हम जाल सेट करेंगे, लेकिन बाकी?

एक विशेष कोशिश भी है {} ब्लॉक जिसके अंदर "अदृश्य" CATCH ब्लॉक है, और यदि इस ब्लॉक के अंदर कोई अपवाद होता है, तो स्क्रिप्ट काम करना बंद नहीं करेगी और इस ब्लॉक के बाद अगले निर्देश के साथ निष्पादन जारी रहेगा। इस प्रकार, आप केवल उन सभी अपवादों को नजरअंदाज कर सकते हैं जो हम भर में आते हैं।

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

-और अगर वह भागने की कोशिश करता है?

यह संभव है कि एक अपवाद के प्रसंस्करण के दौरान, हम एक और एक प्राप्त कर सकते हैं। हालांकि, यह ध्यान देने योग्य है कि कब या डिफ़ॉल्ट ब्लॉक, जिसमें प्रसंस्करण होता है, सबसे सामान्य ब्लॉक हैं, जिसके अंदर आप फिर से CATCH ब्लॉक रख सकते हैं:

 sub Func($a) { try { my $temp = $a*2; say "Test work"; CATCH { when X::Str::Numeric { die "test"; CATCH { default { say "Another die action"; } } } default { say "Something is wrong! "~$_.WHAT.gist; } } } } Func "Test"; say "Another test work"; 

-और चलो अपवादों के एक जोड़े को वश में करने की कोशिश करते हैं?

शायद हमारे पास खुद को अपवाद बनाने के कुछ तरीके हैं:

पहला तरीका यह है कि आपने पहले ही 'डाई' स्टेटमेंट देखा है:

 { die "I'm diying..."; CATCH { default { say "I will save you!"; } } } 

दूसरा तरीका फेंक विधि को कॉल करना है:

 { X::Str::Numeric.throw; CATCH { default { say "More exception!?!"; } } } 

यह भी ध्यान देने योग्य है कि आपकी कक्षा को अपवाद वर्ग से विरासत में लेना संभव है, जिसके परिणामस्वरूप हम अपने स्वयं के अपवाद बना सकते हैं, लेकिन अभी तक हम बिना उदाहरण के करेंगे।

इस पर, मैं अपवादों की क्रूर दुनिया में अस्तित्व पर अपने छोटे गाइड को समाप्त करना चाहूंगा। मुझे आशा है कि आप रुचि रखते हैं।