Wikilivres

Programmation PHP/Exceptions

< Programmation PHP
Analyse statique de programmes Analyse statique de programmes
Xdebug Xdebug

[ Modifier le sommaire ]

Analyse statique de programmes Analyse statique de programmes
Xdebug Xdebug

Tester l'existence

modifier

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

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

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 
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.

 

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

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

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

Affichage d'une trace lisible

modifier

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

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

 

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

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

throw new \Exception('Trace');

Exception::getTraceAsString()

modifier

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

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

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 soient horodatés et 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

 

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
  1. ↑ https://www.php.net/manual/fr/language.errors.php7.php
  2. ↑ http://php.net/manual/fr/function.set-exception-handler.php
  3. ↑ http://php.net/manual/fr/function.trigger-error.php
  4. ↑ https://symfony.com/doc/current/logging.html
  5. ↑ https://www.php-fig.org/psr/psr-3/
  6. ↑ https://symfony.com/doc/current/logging/monolog_console.html
Récupérée de « https://fr.wikibooks.org/w/index.php?title=Programmation_PHP/Exceptions&oldid=700597 »