php: catch exception y continue execution, ¿es posible?

Question

¿Es posible detectar excepciones y continuar con la ejecución del script?

Answer 1

Claro, sólo detectar la excepción en la que desea continuar con la ejecución ...

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

Por supuesto, esto tiene el problema de la caída en silencio lo que podría ser un error muy importante. SomeOperation() puede fallar y causar otros problemas sutiles y difíciles de resolver, pero nunca se sabrá si se cae silenciosamente la excepción.

Answer 2

Claro:

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

Es posible que desee ir a tomar una lectura de la documentación de PHP en Exceptions.

Answer 3

Sí.

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

sin embargo en cuenta que php también tiene códigos de error separan de excepciones, un vestigio de la herencia antes de php oop tenía primitivas. La mayoría de los builtins de biblioteca aún generan códigos de error, no excepciones. Para ignorar una llamada de código de error de la función de prefijo con @:

@myfunction(); 

Answer 4

Sí, pero depende de lo que desea ejecutar:

P. ej

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

c(); 

c() se ejecutará siempre. Pero si a() lanza una excepción, b() es no ejecutado.

Solo coloque las cosas en el bloque try que depende uno del otro. P.ej. b depende de algún resultado de a no tiene sentido poner b después del bloque try-catch.

Answer 5

Otro ángulo en esto es devolver una excepción, NO arrojar una, desde el código de procesamiento.

Necesitaba hacer esto con un framework de plantillas que estoy escribiendo. Si el usuario intenta acceder a una propiedad que no existe en los datos, I devuelve el error desde el fondo de la función de procesamiento, en lugar de tirarlo.

Luego, en el código de llamada, puedo decidir si lanzar este devolvió el error, haciendo que el intento() para capturar(), o simplemente continuar:

// 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; 

El resultado de esto es todavía consigo el contexto del error original, a pesar de que fue lanzado en la parte superior.

Otra opción sería devolver un objeto NullObject personalizado o un objeto UnknownProperty y compararlo antes de decidir desconectar el catch(), pero como puede volver a lanzar errores de todos modos, y si tiene el control total del estructura general, creo que esta es una buena manera de resolver el problema de no poder continuar try/capturas.

Answer 6

Una vieja pregunta, pero una que tenía en el pasado cuando salía de VBA scipts a php, donde podíamos "Ir a" para volver a introducir un bucle "En caso de error" con un "Currículum" y fuera se fue todavía procesando la función.
En php, después de un poco de prueba y error, ahora uso try {} catch {} anidado para procesos críticos versus no críticos, o incluso para llamadas de clase interdependientes para poder rastrear mi camino hasta el inicio del error. p. si la función B depende de la función de una, pero la función c es un bueno tener, pero no debe detener el proceso, y todavía quieren saber los resultados de los 3 independientemente, esto es lo que hago:

//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(); 
    } 
} 

Ahora Puedo recorrer mi matriz de resultados para cada clave y evaluar los resultados. Si hay una falla crítica para a() o b().
Todavía tengo un punto de referencia sobre qué tan lejos llegó antes de que ocurriera una falla crítica dentro de $ resultArr y si el manejador de excepciones está configurado correctamente, sé si fue un() o b() que falló.
Si c() falla, el ciclo continúa. Si c() falló en varios puntos, con un poco de lógica de bucle post adicional puedo incluso averiguar si c() funcionó o tuvo un error en cada iteración al interrogar $ resultArr [$ key] [2].