¿Qué son las excepciones en Laravel?

Spanish (Español) translation by Rolando Gonzalez (you can also view the original English article)

Como desarrollador de PHP, puedes utilizar excepciones, porque te permiten saber cuando algo ha ido mal o el usuario ha actuado de una manera inusual (por ejemplo, división por cero). Sin excepciones, tu aplicación acabaría mostrando errores no deseados y sería mucho más difícil de depurar. También es importante detener la ejecución inmediatamente y tomar otra acción en curso.

Las excepciones son realmente simples, y facilitarn tu progreso de desarrollo. Cuando aprendas cómo utilizar las excepciones, serán una parte habitual en tu desarrollo.

¿Qué es una excepción?

Creo que la mejor definición de las excepciones ha sido dada por Martin Fowler:

Excepciones señalan algo fuera de los límites esperados de comportamiento del código en cuestión.

Exactamente, de hecho, una excepción es un evento que se produce durante la ejecución de un programa, que interrumpe el flujo normal de las instrucciones del programa. Cuando usted throw (lanza) (crear un objeto de excepción y se lo entrega al sistema en ejecución) una excepción, el sistema catch lo atrapará y buscará el manejo apropiado devolviendo el mensaje adecuado.

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

}

¿Cuando necesitas utilizar excepciones?

Utiliza excepciones cuando tu sistema se enfrenta con circunstancias excepcionales que impiden que el sistema la pueda asumir. Utilizamos las excepciones solamente cuando el sistema no es capaz de determinar lo que ha sucedido. Martin Fowler cree que "Si un fallo es el comportamiento esperado, entonces no deberías usar excepciones". Esto significa que debes utilizar excepciones donde no eres capaz de determinar el error. Las excepciones sólo deberían utilizarse en circunstancias excepcionales.

Nota: Las excepciones no son buenas para el manejo de las operaciones lógicas.

Para un sistema como validación entradas hechas por el usuario, utilizar excepciones estaría mal. En primer lugar, se determinará el texto de entrada, y en una aplicación como esta debemos reportar varios errores en lugar de un solo error. Creo en la eliminación del uso de excepciones en cualquier circunstancia donde podríamos esperar errores de validación.

Capturar una excepción es muy importante, porque si no capturas una excepción el sistema devolverá un error. La operación de captura debe ser lo más cerca del punto de falla como sea posible.

¿Cuáles son las excepciones en Laravel?

Laravel utiliza exception Handler (controlador de excepción), que es una clase en App\Exceptions\Handler.php. Esta clase contiene dos métodos principales (el método renderHttpException, que se utiliza para todas las excepciones de HTTP, como 404s y 503s, está en la clase padre de controlador). El primero es report (reporte), que se utiliza para registrar las excepciones o enviarlos a un servicio externo. Aquí un ejemplo del método de reporte:


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

    return parent::report($e);
}

El segundo es render renderizar. El método render (renderizar) es responsable de convertir una determinada excepción en una respuesta HTTP que se enviara al navegador. Aquí está un ejemplo del método de render (renderizar):

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

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

Nota: Puedes utilizar la propiedad $dontReport (No reportar) del controlador de excepciones para ignorar las excepciones por tipo.

Puedes reemplazar los métodos de excepción en Laravel con tu propia excepción así:

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

Esto se mostrará cuando config debug es true (configuración debug es verdadera).

¿Cómo crear tu propia excepción Laravel?

Puede que necesites crear tu propia clase de excepción. Necesitas extender de la clase de excepción base de Laravel, he creado una clase abstracta que se comporta como la clase base de la clase de excepción personalizada. Crear un archivo en 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];
    }
}

Y la clase de excepción:

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

Puedes utilizar la clase anterior en tu código:

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

Al lado del núcleo de Laravel de la clase de excepción, puedes utilizar el paquete de Assertion (afirmación). Este se puede utilizar como una clase externa de excepción; puede usar esto para saltar los bloques if en tu código.

Para instalar el paquete Assertion, debes ejecutar el siguiente comando:

1	composer require beberlei/assert

Por ejemplo, si quieres comprobar la dirección de correo electrónico de un usuario, puedes hacerlo as:

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

Conclusión

Independientemente del lenguaje que desees usar, es muy importantes entender las excepciones ya que nos ayudan a controlar la ejecución del flujo de una aplicación.

Además, las excepciones nos ayuda a registrar problemas cuando se producen y ayudan a hacer que nuestra aplicación sea más robusta.

Como puedes observar en el trabajo cubierto en este tutorial, Laravel es un framework que ofrece gran funcionalidad del manejo de las excepciónes web y las aplicaciones web.

¡Sé el primero en conocer las nuevas traducciones–sigue @tutsplus_es en Twitter!

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	}