Programmation PHP/Exceptions

Un livre de Wikilivres.
Aller à la navigation Aller à la recherche


Tester l'existence[modifier | modifier le wikicode]

Pour éviter les warnings de variables inexistantes il vaut mieux les initialiser au début. Si toutefois cela s'avère impossible, on recourt à des tests sur les fonctions suivantes pour le faire :

if (!isset($maVariable)) { $maVariable = ''; }
if (!defined('MA_CONSTANTE')) { define('MA_CONSTANTE', ''); }
if (!function_exists('maFonction')) { function maFonction() {} }

empty()[modifier | modifier le wikicode]

Permet de savoir si une variable est définie et si contient une valeur. Son comportement s'adapte au type de la variable. Cela équivaut à :

  • String : isset($v) and $v == ''.

ou

  • Booléen : isset($v) and $v == false.

ou

  • Tableau : isset($v) and sizeof($v) == 0.

try... catch[modifier | modifier le wikicode]

Tout comme en Java, la levée d'exception est assurée par un bloc try... catch. Cela permet à un script de poursuivre son exécution malgré les erreurs (ex : panne réseau), et ainsi de ne pas bloquer l'utilisateur sur une page blanche ou en anglais destinée au développeur.

Ces interruptions sont représentées par des classes qui héritent toutes du type Throwable, qui a deux classes filles : Error et Exception[1].

Exemples[modifier | modifier le wikicode]

try {
  echo '1 / 2 = ' 1/2;
  echo '3 / 0 = ' 3/0; // instruction qui déclenchera l'exception
  echo '2 / 1 = ' 2/1; // cette instruction ne sera pas exécutée à cause de la précédente
}
catch (Exception $e) {
  echo $e->getMessage(); // afficher le message lié à l'exception
}

Il n'est donc pas nécessaire de prévoir ce qui peut interrompre le programme pour s'en prémunir et poursuivre l'exécution en fonction.

La classe de gestion des erreurs nommée Exception est gracieusement mise à votre disposition par l’interpréteur dans les versions ultérieures à PHP 5.0.

Autre exemple d’utilisation :

class Humain
{
  var $age;

  function __construct($combien)
  {
    $this->age = $combien;
   
    try {
      if ($this->age<0)
      throw new Exception('Un peu jeune');
      if ($this->age>200)
      throw new Exception('Un peu vieux');
    } catch (Exception $e) {
      echo $e->getMessage();
      return;
    }
  }

}

//Retournera un message d'erreur
$humain = new Humain(700);
$humain = new Humain(-3);

//Sans erreur
$humain = new Humain(16);
 le bloc finally ajouté après les catch sera exécuté après les instructions du try et des catch.
Logo La bonne pratique est de ne jamais envoyer \Exception directement mais d'utiliser ses sous-classes, qui ont de plus généralement le bon code HTTP (au lieu de erreur 500). Par exemple sur Symfony, les erreurs inhérente à l'utilisateur (400) sont accessibles dans le namespace Symfony\Component\HttpKernel\Exception.


Par ailleurs, il est possible de créer ses propres classes d'exceptions, et de modifier les exceptions natives PHP avec set_exception_handler()[2].

Recréer une exception ou une erreur[modifier | modifier le wikicode]

Les Throwable PHP sont immutables, pour les modifier il faut donc les recréer. Pour faciliter cela, ils possèdent depuis PHP7 une méthode getPrevious(), dont le résultat injecté en troisième argument du constructeur d'un autre, permet de cloner l'objet. Ex :

        try {
            crash();
        } catch (\Exception $e) {
            throw new \Exception('Nouveau message + ancien : '.$e->getMessage(), $e->getCode(), $e->getPrevious());
        }

NB : la classe Throwable n'est pas instanciable directement.

trigger_error()[modifier | modifier le wikicode]

Cette fonction lance une exception du type placé en second paramètre, dont certains peuvent stopper l'exécution du programme[3]. Par exemple :

  trigger_error('Message d'erreur', E_USER_ERROR);

Affiche : ErrorException. User Error: Message d'erreur.

La liste des types d'erreur est disponible sur http://php.net/manual/fr/errorfunc.constants.php.

Logs[modifier | modifier le wikicode]

Affichage d'une trace lisible[modifier | modifier le wikicode]

Afin de clarifier la trace de l'exécution des scripts, il peut être utile de formater celle-ci avec la balise <pre> :

if ($debogage) {
  print '<pre>';
  var_dump(scandir('.'));
  print '</pre>';
}

NB : on rappelle que les commandes ini_set('display_errors', 1); et error_reporting(E_ALL); permet d'afficher à l'écran toutes les erreurs et avertissements.


Voici une manière de n'afficher les erreurs que lors du débogage :

if ($debogage) {
  error_reporting(E_ALL);
} else {
  error_reporting(0);
}

Pour créer une bonne gestion des erreurs, partez du principe que l'utilisateur est imprévisible, et qu'il va justement faire ce qu'il ne faut pas (Loi de Murphy). Envisagez toutes les possibilités et trouvez-y une solution, en testant les exceptions (ex : caractères d'échappements ou symboles non ASCII comme des sinogrammes pour voir s'ils s'affichent bien).


debug_backtrace et debug_print_backtrace[modifier | modifier le wikicode]

Ces fonction affichent automatiquement la trace de l'exécution menant à elles.

Logo Sur un framework cela peut être trop long à exécuter, il faut donc ne faire afficher que les noms des fichiers exécutés avec l'argument suivant :
echo '<pre>'; debug_print_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS);echo '</pre>';
$logFile = fopen('debug.log', 'a+');
fwrite($logFile, json_encode(debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS)).PHP_EOL);
fclose($logFile);

throw[modifier | modifier le wikicode]

Si l'affichage de la trace doit être suivi d'une interruption du programme, utiliser :

throw new \Exception('Trace');

Exception::getTraceAsString()[modifier | modifier le wikicode]

Si l'exception ne surgit pas avec un throw, on peut afficher la trace depuis avec sa méthode :

echo $e->getTraceAsString();

Fichier de log maison[modifier | modifier le wikicode]

Bien souvent on ne peut pas afficher les logs dans le navigateur ou rapidement via le logeur existant, donc il faut recourir à la création d'un nouveau fichier de log temporaire :

$logFile = fopen('debug.log', 'a+');
fwrite($logFile, $maVariable.PHP_EOL);
fclose($logFile);

Symfony[modifier | modifier le wikicode]

Depuis une commande Symfony, on peut afficher des logs en console :

$output->writeln('Update complete');

Mais le mieux est d'utiliser la bibliothèque Monolog[4] (compatible PSR-3[5]), pour que les logs s'enregistrent dans var/log/ (puisque les commandes peuvent être lancées par cron et donc sans affichage en console). De plus, Monolog est configurable pour afficher en plus ces logs en console[6] (ce qui est fait par défaut sur la v3.3 dans config/packages/dev/monolog.yaml).

composer require symfony/monolog-bundle

Pour booster ses performances, on peut le régler ainsi dans monolog.yaml :

monolog:
    use_microseconds: false
Logo Quand l'application tourne sur plusieurs serveurs frontaux, il vaut mieux centraliser les logs dans un agrégateur de logs comme Kibana ou Graylog. Or, dedans il est possible que tous les logs ne soient pas visibles. Par exemple en cas de caractères spéciaux dans les clés des tableaux, tels que ">" ou "$", ou en cas de valeur NULL :
$a = 'HelloWorld!';
$this->logger->info('Test d\'affichage.', [
    '$a' => $a,  // absent de Graylog
    'a' => $a,   // visible
    'b' => null, // absent de Graylog
]);


 c'est une raison pour ne pas inclure de variable dans le message et de ne les mettre que dans le tableau, en plus de pouvoir retrouver tous les logs similaires plus facilement.

Références[modifier | modifier le wikicode]