रूबी में "शुरू" और "बचाव" कीवर्ड का उपयोग कैसे करें

रूबी में एक आम समस्या यह है कि आपको त्रुटि संदेश मिलते हैं, जिन्हें तकनीकी शब्दों में हम "अपवाद" कहते हैं।

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

आज आप अपेक्षित त्रुटियों को प्रबंधित करना सीखेंगे।

कैसे?

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

वे कैसे काम करते हैं?

सबसे पहले, आपको कुछ समझने की जरूरत है।

आपके रूबी प्रोग्राम चलने के दौरान कई बिंदुओं पर एक त्रुटि को ट्रिगर कर सकते हैं।

उदाहरणों में शामिल हैं :

• एक गैर-मौजूदा फ़ाइल को पढ़ने का प्रयास कर रहा है।
• किसी संख्या को शून्य से विभाजित करना।
• जिस वेब सर्वर के साथ आप काम कर रहे हैं उसका SSL प्रमाणपत्र पुराना है।

जब कोई त्रुटि होती है... रूबी तुरंत दुर्घटनाग्रस्त नहीं होती!

आपको त्रुटि से उबरने का मौका मिलता है . हम इसे "अपवाद प्रबंधन" कहते हैं।

रूबी आपको अपने कोड में त्रुटि पुनर्प्राप्ति को लागू करने के लिए कुछ कीवर्ड देता है। ये कीवर्ड हैं begin &rescue ।

आइए जानें कि उनका उपयोग कैसे करें!

रूबी अपवादों को कैसे हैंडल करें

आप इन अपवादों को कैसे संभालते हैं?

आप अपवाद उत्पन्न करने वाले कोड को begin . के साथ लपेट सकते हैं / rescue ब्लॉक करें।

यहां बताया गया है कि यह कैसे काम करता है…

पहला खंड (begin ), आपके पास वह कोड है जिसे आप चलाने जा रहे हैं और जो अपवाद उत्पन्न कर सकता है।

उदाहरण :

begin
  IO.sysopen('/dev/null')
rescue
  # ...
end

यहां हम sysopen . के साथ एक फ़ाइल खोलने का प्रयास कर रहे हैं . यदि हम फ़ाइल नहीं खोल सकते हैं तो एक अपवाद उठाया जाता है।

rescue . का उपयोग करने का यह सही समय है कीवर्ड!

इस कीवर्ड का उपयोग करके आप कह सकते हैं कि अपवाद उठाए जाने पर आप क्या करना चाहते हैं। तो विफलता मोड आपके नियंत्रण में है।

उदाहरण :

begin
  IO.sysopen('/dev/null')
rescue
  puts "Can't open IO device."
end

आप इस त्रुटि को लॉग करना चाहते हैं और शायद किसी प्रकार का डिफ़ॉल्ट मान प्रदान करना चाहते हैं।

मत। नज़रअंदाज़ करना। त्रुटियाँ।

एकाधिक अपवादों को बचाना

आपको पता होना चाहिए कि rescue एक वैकल्पिक तर्क लेता है।

यह तर्क क्या है?

यह तर्क अपवाद वर्ग . है जिससे आप बचाव करना चाहते हैं।

यह इस बात पर निर्भर करता है कि आप कौन सा कोड चला रहे हैं।

IO के लिए :

• यह Errno::ENOENT हो सकता है गुम फ़ाइल के लिए
• या Errno::EACCES अनुमति त्रुटि के लिए

सबसे अच्छी बात?

आप एक ही शुरुआत/बचाव ब्लॉक में कई अपवादों को संभाल सकते हैं।

इसे पसंद करें :

begin
  IO.sysopen('/dev/null')
rescue Errno::ENOENT
  puts "File not found."
rescue Errno::EACCES
  puts "Insufficient permissions, not allowed to open file."
end

यदि आप चाहते हैं कि एक ही क्रिया एक से अधिक अपवादों के लिए हो...

आप यह कर सकते हैं :

begin
  IO.sysopen('/dev/null')
rescue Errno::ENOENT, Errno::EACCES
  puts "There was an error opening the file."
end

आइए सीखते रहें!

ब्लॉक और विधियों के अंदर अपवादों को कैसे बचाया जाए

आपको हमेशा begin . का उपयोग करने की आवश्यकता नहीं है कीवर्ड।

ऐसे मामले हैं जहां आप इसे छोड़ सकते हैं।

कहां?

अंदर के तरीके और ब्लॉक।

उदाहरण :

def get_null_device
  IO.sysopen('/dev/null')
rescue Errno::ENOENT
  puts "Can't open IO device."
end

विधि परिभाषा स्वयं begin . का काम करती है , ताकि आप इसे छोड़ सकें।

आप इसे ब्लॉक के साथ भी कर सकते हैं।

उदाहरण :

["a.txt", "b.txt", "c.txt"].map do |f|
  IO.sysopen(f)
rescue Errno::ENOENT
  puts "Can't open IO device: #{f}."
end

अब, rescue . का उपयोग करने का एक और तरीका है बिना begin . के कीवर्ड ।

आइए देखें कि यह कैसे काम करता है।

इनलाइन बचाव को समझना और यह खतरनाक क्यों है

आप rescue . का उपयोग कर सकते हैं इनलाइन।

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

यहां एक उदाहरण दिया गया है :

["a.txt", "b.txt", "c.txt"].select { |f| File.open(f) rescue nil }.map(&:size)

यह आपको केवल उन फ़ाइलों को खोलने की अनुमति देता है जो मौजूद हैं और जो नहीं हैं उन्हें अनदेखा करें।

परिणामस्वरूप, आपको मौजूदा फ़ाइलों का आकार मिलता है।

अपवादों को उठाए बिना।

ऐसा क्यों करते हैं?

खैर, यह आपको अपने कोड को एक पंक्ति में रखने देता है।

बस इतना ही।

rescue . के इस रूप का उपयोग करते समय एक "छिपा हुआ खतरा" होता है क्योंकि आपको StandardError . से आने वाले सभी अपवाद मिल रहे हैं ।

जो सबसे अधिक अपवाद हैं।

यह अच्छा क्यों नहीं है?

क्योंकि उनके विस्तृत चयन के बजाय केवल विशिष्ट अपवादों को ही संभालना सबसे अच्छा है।

यह स्वयं से त्रुटियों को छिपाने से बचता है!

छिपी हुई त्रुटियां सभी प्रकार के अजीब व्यवहार और हार्ड-टू-डीबग मुद्दों को जन्म दे सकती हैं।

सारांश

आपने रूबी में त्रुटियों, बुनियादी अपवाद प्रबंधन और rescue . के बारे में सीखा है / begin कीवर्ड।

कृपया इस लेख को साझा करें यदि आपको यह मददगार लगा

पढ़ने के लिए धन्यवाद!