php: अपवाद पकड़ें और निष्पादन जारी रखें, क्या यह संभव है?

Question

क्या अपवाद पकड़ना और स्क्रिप्ट का निष्पादन जारी रखना संभव है?

Answer 1

ज़रूर, सिर्फ अपवाद जहां निष्पादन जारी रखना चाहते हैं ...

try 
    { 
     SomeOperation(); 
    } 
    catch (SomeException $e) 
    { 
     // do nothing... php will ignore and continue  
    } 

बेशक यह चुपचाप छोड़ने क्या एक बहुत ही महत्वपूर्ण त्रुटि हो सकती है की समस्या है पकड़ने। कुछ ऑपरेशन() अन्य सूक्ष्म, समस्याओं को समझने में मुश्किल होने में असफल हो सकता है, लेकिन आप कभी नहीं जानते कि क्या आप चुपचाप अपवाद छोड़ देते हैं।

Answer 2

ज़रूर:

try { 
    throw new Exception('Something bad'); 
} catch (Exception $e) { 
    // Do nothing 
} 

आप Exceptions पर पीएचपी दस्तावेज़ीकरण का एक पढ़ा है जाने के लिए चाहते हो सकता है।

Answer 3

हां।

try { 
    Somecode(); 
catch (Exception $e) { 
    // handle or ignore exception here. 
} 

तथापि से पहले php OOP पुरातन था, ध्यान दें एक विरासत पकड़ मिली थी कि php भी त्रुटि कोड अपवादों से अलग। अधिकांश लाइब्रेरी बिल्टिन अभी भी त्रुटि कोड उठाते हैं, अपवाद नहीं। एक त्रुटि कोड कॉल समारोह @ उपसर्ग के साथ उपेक्षा करने के लिए:

@myfunction(); 

Answer 4

हाँ, लेकिन यह निर्भर करता है कि आप क्या निष्पादित करने के लिए करना चाहते हैं:

जैसे

try { 
    a(); 
    b(); 
} 
catch(Exception $e){ 
} 

c(); 

c() हमेशा निष्पादित किया जाएगा। लेकिन अगर a() अपवाद फेंकता है, b() निष्पादित नहीं है।

केवल सामान को try ब्लॉक पर डालें जो एक दूसरे पर निर्भर है। जैसे ba के कुछ नतीजे पर निर्भर करता है try-catch ब्लॉक के बाद b डालने का कोई मतलब नहीं है।

Answer 5

इस पर एक और कोण प्रसंस्करण कोड से एक अपवाद वापस नहीं कर रहा है, एक फेंक रहा है।

मुझे इसे लिखने वाले एक टेम्पलेटिंग फ्रेमवर्क के साथ ऐसा करने की ज़रूरत है। यदि उपयोगकर्ता किसी ऐसी संपत्ति तक पहुंचने का प्रयास करता है जो डेटा पर मौजूद नहीं है, तो मैं लौटने की बजाय प्रसंस्करण फ़ंक्शन के भीतर गहराई से त्रुटि लौटाता हूं।

फिर, बुला कोड में, मैं तय कर सकते हैं कि क्या यह त्रुटि दी फेंक, कोशिश() को पकड़ने के लिए() पैदा कर रहा है, या बस जारी रखने के लिए:

// process the template 
    try 
    { 
     // this function will pass back a value, or a TemplateExecption if invalid 
      $result = $this->process($value); 

     // if the result is an error, choose what to do with it 
      if($result instanceof TemplateExecption) 
      { 
       if(DEBUGGING == TRUE) 
       { 
        throw($result); // throw the original error 
       } 
       else 
       { 
        $result = NULL; // ignore the error 
       } 
      } 
    } 

// catch TemplateExceptions 
    catch(TemplateException $e) 
    { 
     // handle template exceptions 
    } 

// catch normal PHP Exceptions 
    catch(Exception $e) 
    { 
     // handle normal exceptions 
    } 

// if we get here, $result was valid, or ignored 
    return $result; 

इसी का परिणाम मैं अभी भी कर रहा है मूल त्रुटि का संदर्भ, भले ही इसे शीर्ष पर फेंक दिया गया हो।

एक और विकल्प कस्टम नलऑब्जेक्ट या अज्ञात प्रॉपर्टी ऑब्जेक्ट को वापस करने और कैच() को यात्रा करने का निर्णय लेने से पहले इसकी तुलना करने के लिए हो सकता है, लेकिन जैसा कि आप त्रुटियों को फिर से फेंक सकते हैं, और यदि आप पूरी तरह से नियंत्रण में हैं समग्र संरचना, मुझे लगता है कि यह कोशिश/पकड़ने में सक्षम नहीं होने के मुद्दे के चारों ओर एक साफ रास्ता है।

Answer 6

एक पुराना सवाल है, लेकिन एक अतीत में जब मैंने वीबीए से निकलते हुए php से दूर आना था, जहां आप "फिर से शुरू करें" के साथ "त्रुटि पर" लूप को फिर से दर्ज करने के लिए "GoTo" कर सकते थे और यह दूर चला गया अभी भी कार्य प्रसंस्करण।
PHP में, कुछ परीक्षण और त्रुटि के बाद, अब मैं गंभीर बनाम गैर महत्वपूर्ण प्रक्रियाओं के लिए नेस्टेड प्रयास {} पकड़ {} का उपयोग करता हूं, या यहां तक ​​कि परस्पर निर्भर वर्ग कॉल के लिए भी, ताकि मैं त्रुटि की शुरुआत में अपना रास्ता वापस देख सकूं। उदा। यदि समारोह ख समारोह एक पर निर्भर है, लेकिन समारोह ग के लिए एक अच्छा है, लेकिन प्रक्रिया बंद नहीं करना चाहिए, और मैं अभी भी परवाह किए बिना सभी 3 के परिणामों में जानना चाहते हैं, यहाँ मैं क्या कर रहा है:

//set up array to capture output of all 3 functions 
$resultArr = array(array(), array(), array()); 

// Loop through the primary array and run the functions 
foreach($x as $key => $val) 
{ 
    try 
    { 
     $resultArr[$key][0][] = a($key); 
     $resultArr[$key][1][] = b($val); 
     try 
     { // If successful, output of c() is captured 
      $resultArr[$key][2][] = c($key, $val); 
     } 
     catch(Exception $ex) 
     { // If an error, capture why c() failed 
      $resultArr[$key][2][] = $ex->getMessage(); 
     } 
    } 
    catch(Exception $ex) 
    { // If critical functions a() or b() fail, we catch the reason why 
     $criticalError = $ex->getMessage(); 
    } 
} 

अब मैं प्रत्येक कुंजी के लिए अपने परिणाम सरणी के माध्यम से लूप कर सकते हैं और परिणामों का आकलन कर सकते हैं। यदि() या बी() के लिए कोई महत्वपूर्ण विफलता है।
मुझे अभी भी संदर्भ है कि $ resultArr में महत्वपूर्ण विफलता होने से पहले कितनी दूर हो गई है और यदि अपवाद हैंडलर सही तरीके से सेट किया गया है, तो मुझे पता है कि यह एक() या बी() विफल रहा है या नहीं।
यदि सी() विफल रहता है, तो लूप जारी रहता है। यदि सी() कुछ बिंदुओं पर विफल रहा है, तो कुछ अतिरिक्त पोस्ट लूप तर्क के साथ मैं यह भी पता लगा सकता हूं कि सी() ने काम किया है या $ resultArr [$ key] [2] पूछताछ करके प्रत्येक पुनरावृत्ति पर कोई त्रुटि हुई है।