Que sont les Exceptions de Laravel?

() translation by (you can also view the original English article)

En tant que développeur PHP, vous utilisez peut-être les exceptions, car elles vous permettent de remarquer lorsque quelque chose se passe mal ou que l'utilisateur a fait une erreur de manipulation (comme une division par zéro). Sans les exceptions, votre application finirait par afficher des erreurs indésirables et serait bien plus difficile à débugger. Il est aussi important que vous arretiez l'exécution immédiatement et qu'une autre action prenne le relais.

Les exceptions sont vraiment simples et permettent une évolution plus facile du développement. Une fois maitrisé l'utilisation des exceptions, elles feront parties intégrantes de vos développements.

Qu'est-ce qu'une Exception?

Je pense que la meilleure définition des exceptions est donnée par Martin Fowler:

Les exceptions signalent quelque chose qui se passe en dehors des limites du comportement attendu du code en question.

Pour être précis, une exception est un événement, qui se produit pendant l'exécution d'un programme, qui perturbe le déroulement normal des instructions du programme. Quand vous lancez une exception - throw (créer un objet d'exception et rendre la main au système) - le système va la capturer - catch - en recherchant le handler approprié et retourner le bon message.

try { 
    // the code goes here 
} catch (Exception $e) { 
    // if an exception happened in the try block above 

}

Quand devons-nous utiliser les exceptions?

Utilisez les exceptions lorsque votre système se trouve face à des circonstances exceptionnelles qu'il ne peut pas gérer. On n'utilise les exceptions seulement lorsque le système ne peut pas déterminer ce qui c'est passé. Martin Fowler croit que "si l'erreur est un comportement possible, alors il ne faut pas utiliser les exceptions". Cela veut dire que vous devez utiliser les exceptions lorsque vous n'êtes pas en mesure de déterminer l'erreur. Les exceptions ne devraient être utilisées que dans des circonstances exceptionnelles.

Note: les exceptions ne sont pas bonnes pour gérer une logique dans le code.

Pour une opération comme la validation de données entrantes, utiliser les exceptions est mal. Premièrement, le texte entrant doit être déterminer, et une application comme celle là doit retourner une collection d'erreurs et non pas une seule erreur. Je crois qu'il faut éliminer l'utilisation des exceptions dans toutes les circonstances où l'on peut rencontrer des erreurs de validation.

Capturer une exception est très important, sans quoi le système va retourner une erreur. L'opération de capture doit être la plus proche possible du point qui pourrait déclencher l'exception.

Que sont les exceptions de Laravel?

Laravel utilise des Handler d'exception, qui est une classe dans App\Exceptions\Handler.php. Cette classe contient deux méthodes principales (la méthode renderHttpException qui est utilisée pour toutes les exceptions HTTP, comme les 404 et 503, est dans la classe parent du Handler). La première est report, qui est utilisée pour logger les exceptions ou les envoyer vers un service externe. Voici un exemple de la méthode report:


public function report(Exception $e)
{
    if ($e instanceof CustomException) {
        //
    }

    return parent::report($e);
}

La seconde est render. La méthode render est responsable de la convertion d'une exception en réponse HTTP qui doit être retournée au navigateur. Voici un exemple de méthode render:

public function render($request, Exception $e)
{
    if ($e instanceof CustomException) {
        return response()->view('errors.custom', [], 500);
    }

    return parent::render($request, $e);
}

Note: vous pouvez utilser la propriété $dontReport du handler d'une exception pour ignorer des exceptions par type.

Vous pouvez changer les méthodes des exceptions Laravel par les vôtre de cette façon:

public function render($request, Exception $e)
{
    if (config('app.debug')) {
        return parent::render($request, $e);
    }
    return $this->handle($request, $e);
}

Ceci n'appellera la méthode render que si la configuration de debug est à true.

Comment créer vos propres exceptions Laravel?

Vous pourriez avoir besoin de créer vos propre classe d'exceptions. Vous devez étendre la classe de base des exceptions Laravel - J'ai créé une classe abstraite qui servira de base à nos classes d'exceptions. Créez un fichier dans App\Exceptions\monException.php:

namespace App\Exceptions;
use Exception;
abstract class monException extends Exception
{
    protected $id;
    protected $details;
    
    public function __construct($message)
    {
        parent::__construct($message);
    }

    protected function create(array $args)
    {
        $this->id = array_shift($args);
        $error = $this->errors($this->id);
        $this->details = vsprintf($error['context'], $args);
        return $this->details;
    }

    private function errors($id)
    {
        $data= [
            'not_found' => [
                'context'  => 'The requested resource could not be found but may be available again in the future. Subsequent requests by the client are permissible.',
            ]
            //   ...
        ];
        return $data[$id];
    }
}

Et la classe d'exception:

namespace App\Exceptions;
class NotFoundmonException extends  monException
{
    public function __construct()
    {
        $message = $this->create(func_get_args());
        parent::__construct($message);
    }
}

Vous pouvez utiliser la classe ci-dessus dans votre code:

    try {
        throw new \App\Exceptions\NotFoundmonException('not_found');
    }
    catch(\App\Exceptions\NotFoundmonException $e)
    {
        return $e->getMessage();
    }

En parallèle de la classe d'exception du coeur de Laravel, vous pouvez utiliser le module Assertion. Il peut être utilisé comme une classe d'exception, vous pouvez l'utiliser pour éviter les blocs if spaghetti dans votre code.

Pour installer le module Assertion, vous devez taper la commande suivante:

1	composer require beberlei/assert

Par exemple, si vous souhaitez vérifier l'adresse email d'un utilisateur, vous pouvez faire ceci:

use Assert\Assertion;
use Assert\AssertionFailedException;
//...
try {
    Assertion::email($value, "The value must be valid E-mail address");
} catch(AssertionFailedException $e) {
    $e->getValue(); // the value that caused the failure
    $e->getConstraints(); // the additional constraints of the assertion.
}

Conclusion

Indépendemment du language que vous choisissez d'utiliser, les exceptions sont très importantes à comprendre car elles nous aident à garder le contrôle sur le déroulement de l'exécution d'une application.

De plus, elles nous aident à logger les problèmes lorsqu'ils arrivent et rendent l'application plus robuste.

Comme vous pouvez le voir dans le travail de ce tutoriel, Laravel est un framework qui offre d'excellentes fonctionnalitées de capture des exceptions pour le développement d'applications web.

1	namespace App\Exceptions;
2	use Exception;
3	abstract class monException extends Exception
4	{
5	protected $id;
6	protected $details;
7
8	public function __construct($message)
9	{
10	parent::__construct($message);
11	}
12
13	protected function create(array $args)
14	{
15	$this->id = array_shift($args);
16	$error = $this->errors($this->id);
17	$this->details = vsprintf($error['context'], $args);
18	return $this->details;
19	}
20
21	private function errors($id)
22	{
23	$data= [
24	'not_found' => [
25	'context' => 'The requested resource could not be found but may be available again in the future. Subsequent requests by the client are permissible.',
26	]
27	// ...
28	];
29	return $data[$id];
30	}
31	}