Dégradation et erreur sur une fonction PHP

Question

Il existe un moyen de vérifier avec un "IF" si une fonction échoue en php?

Ex.

If (getimagesize($image) returns and error) { 
echo 'Error: function dont work'; 
} 
else 
{ 
// do something 
} 

Merci!

Answer 1

Je suppose que vous êtes intéressé spécifiquement dans une fonction comme getimagesize, qui ne renvoie aucun code d'erreur et le rend dur pour nous. Mais pas impossible.

La documentation pour getimagesize états:

Si l'accès à l'image de nom de fichier est impossible, ou si elle n'est pas une image valide, getimagesize() génère une erreur de niveau E_WARNING. En cas d'erreur de lecture, getimagesize() génère une erreur de niveau E_NOTICE.

Par conséquent, vous devez faire deux choses:

1. être averti de l'erreur et agir sur elle en quelque sorte
2. Avez l'erreur ne soit affiché ou affecter l'exécution de votre programme à tous (après tout, vous êtes allez prendre soin de toutes les erreurs avec le code de gestion des erreurs vous)

Vous pouvez obtenir le premier en utilisant set_error_handler() et restore_error_handler(). Vous pouvez atteindre la seconde avec le error-control operator@.

Ainsi, le code doit aller quelque chose comme ceci:

// Set our own error handler; we will restore the default one afterwards. 
// Our new error handler need only handle E_WARNING and E_NOTICE, as per 
// the documentation of getimagesize(). 
set_error_handler("my_error_handler", E_WARNING | E_NOTICE); 

// No error has occured yet; it is the responsibility of my_error_handler 
// to set $error_occurred to true if an error occurs. 
$error_occurred = false; 

// Call getimagesize; use operator @ to have errors not be generated 
// However, your error handler WILL STILL BE CALLED, as the documentation 
// for set_error_handler() states. 
$size = @getimagesize(...); 

// At this point, my_error_handler will have run if an error occurred, and 
// $error_occurred will be true. Before doing anything with it, restore the 
// previous error handler 
restore_error_handler(); 

if($error_occurred) { 
    // whatever 
} 
else { 
    // no error; $size holds information we can use 
} 


function my_error_handler($errno, $errstr, $file, $line) { 
    global $error_occurred; 

    // If the code is written as above, then we KNOW that an error 
    // here was caused by getimagesize(). We also know what error it was: 
    switch($errno) { 
     case E_WARNING: // Access to image impossible, or not a valid picture 
     case E_NOTICE: // Read error 
    } 

    // We could also check what $file is and maybe do something based on that, 
    // if this error handler is used from multiple places. However, I would not 
    // recommend that. If you need more functionality, just package all of this 
    // into a class and use the objects of that class to store more state. 

    $error_occurred = true; 
    return true; // Do not let PHP's default error handler handle this after us 
} 

Bien sûr, ce n'est pas très maintenable (vous avez une $error_occurred variable globale là, et ce n'est pas une bonne pratique). Donc, pour une solution qui ne fonctionne pas seulement mais qui est également bien conçue, vous empaquetez tout cela dans une classe. Cette classe définirait:

1. Une méthode qui implémente le gestionnaire d'erreur (my_error_handler dans l'exemple ci-dessus). Pour définir une méthode d'objet en tant que gestionnaire d'erreurs au lieu d'une fonction globale, vous devez appeler set_error_handler avec un premier paramètre approprié; voir the documentation for callback.
2. Une méthode qui permet de la classe définir le gestionnaire d'erreur, exécuter un code de votre choix, sauf la « erreur est survenue lors de l'exécution de votre code » drapeau, et restaurer le gestionnaire d'erreurs. Cette méthode pourrait, par exemple, Prenez un callback fourni par votre indicatif et un tableau de paramètres et utilisez call_user_func_array pour l'exécuter. Si, lors de l'exécution, le gestionnaire d'erreurs défini à partir de # 1 ci-dessus est appelé, marquez-le dans une variable de votre objet. Votre méthode renvoie la valeur de retour de call_user_func_array au code appelant.
3. Une méthode ou variable le code appelant peut utiliser pour accéder au résultat de 2 ci-dessus.

Alors, si cette classe est appelée ErrorWatcher, votre code d'appel serait quelque chose comme:

$watcher = new ErrorWatcher; 
$size = $watcher->watch("getimagesize", 
         array(/* params for getimagesize here */)); 

// $size holds your result, if an error did not occur; 
// check for errors and we 're done! 

switch($watcher->report_last_error()) { 
    // error handling logic here 
} 

... qui est agréable et propre et ne plaisante pas avec les variables globales. J'espère que j'ai expliqué cela assez bien pour vous permettre d'écrire vous-même la classe ErrorWatcher. :-)

Answer 2

Jetez un oeil à exceptions. Vous devrez les jeter dans votre fonction cependant.

Edit: Par ailleurs, si votre fonction ne doit retourner un booléen, vous pouvez toujours l'avoir return false si quelque chose va mal et vérifier comme:

$result = getimagesize($image); 

if ($result === false) 
{ 
    // 
} 

Answer 3

Quelle que soit la condition est en une instruction "if" (ce qui est à l'intérieur de la parenthèse) retournera "true" ou "false". Si la condition renvoie "true", la première instruction sera exécutée, sinon la seconde instruction sera exécutée.

Vous pouvez mettre ceci, error_reporting (E_ALL); tout en haut de votre script, juste après votre balise php d'ouverture, pour voir quelle erreur vous obtenez.

Espérons que ça aide.

Peut-être quelque chose comme ceci:

<?php 
error_reporting(E_ALL); 
more stuff here ... 
if(your condition here){ 
echo "condition is true, do something"; 
}else{ 
echo "condition is not true, do something else"; 
} 

si la fonction ou de la déclaration que vous exécutez à l'intérieur du « si » ou « autre » échoue, au moins vous savez que l'on était-il basé sur le résultat et le error_reporting pourrait vous dire pourquoi il a échoué.