Bienvenido a una nueva lección de nuestro curso básico de PHP 8. Hoy nos metemos con las excepciones, una herramienta clave para manejar errores y mantener tus aplicaciones robustas. Si ya manejas traits y namespaces, esto te va a encantar porque es como poner un escudo a tu código. Todo va a ser claro, práctico y con ejemplos que te van a flipar. ¡Empecemos!

¿Qué son las excepciones?

Una excepción es un objeto que representa un error o una situación inusual que ocurre mientras tu programa corre. En lugar de dejar que el error rompa todo, las excepciones te permiten atraparlo, manejarlo y seguir adelante (o al menos mostrar un mensaje claro). Es como si tu código dijera: «¡Ups, algo salió mal, pero yo me encargo!»

En PHP, usamos estas palabras clave:

• try: Envuelve el código que podría fallar.
• catch: Captura la excepción y decide qué hacer.
• throw: Lanza una excepción cuando detectas un problema.
• finally: Ejecuta código pase lo que pase (opcional).

La receta básica es esta:

try {
    // Código que puede fallar
} catch (Exception $e) {
    // Manejar el error
} finally {
    // Código que siempre se ejecuta
}

Probando excepciones en acción

¡Manos a la obra! Crea un archivo excepciones.php en curso_php8 (dentro de C:\xampp\htdocs) y prueba esto:

Ejemplo 1: División con excepciones

<?php
    class Division {
        public function dividirUnNumero($numero) {
            try {
                if (!is_numeric($numero)) {
                    throw new Exception("El valor no es un número");
                }
                if ($numero == 0) {
                    throw new Exception("No se puede dividir por cero");
                }
                echo "El resultado es: " . (2 / $numero) . "<br>";
            } catch (Exception $e) {
                echo "Error: " . $e->getMessage() . "<br>";
            } finally {
                echo "Bloque try-catch finalizado<br>";
            }
        }
    }

    $division = new Division();
    $division->dividirUnNumero(4);    // Válido
    $division->dividirUnNumero(0);    // División por cero
    $division->dividirUnNumero("hola"); // No es número
?>

Abre http://localhost/curso_php8/excepciones.php. Verás:

El resultado es: 0.5
Bloque try-catch finalizado
Error: No se puede dividir por cero
Bloque try-catch finalizado
Error: El valor no es un número
Bloque try-catch finalizado

¿Qué pasó?

• Con 4, la división (2/4 = 0.5) funciona y no hay excepción.
• Con 0, lanzamos una excepción porque no se puede dividir por cero.
• Con "hola", lanzamos otra porque no es un número.
• finally se ejecuta siempre, mostrando que el bloque terminó.

Ejemplo práctico

Ejemplo: Validación de correo

<?php
    class Validador {
        public function validarCorreo($correo) {
            try {
                if (empty($correo)) {
                    throw new Exception("El correo no puede estar vacío");
                }
                if (!filter_var($correo, FILTER_VALIDATE_EMAIL)) {
                    throw new Exception("Correo inválido");
                }
                echo "Correo válido: $correo<br>";
            } catch (Exception $e) {
                echo "Error: " . $e->getMessage() . "<br>";
            } finally {
                echo "Validación completada<br>";
            }
        }
    }

    $validador = new Validador();
    $validador->validarCorreo("ana@example.com");
    $validador->validarCorreo("");
    $validador->validarCorreo("no-es-un-correo");
?>

Resultado:

Correo válido: ana@example.com
Validación completada
Error: El correo no puede estar vacío
Validación completada
Error: Correo inválido
Validación completada

¿Qué pasó?

• Validamos un correo correcto, uno vacío y uno inválido.
• Cada caso lanza una excepción si falla, atrapada por catch.
• finally confirma que siempre terminamos el proceso.

Ejercicio para practicar

¡Tu turno! Ve a curso_php8 y prueba este reto:

1. Validar edad
   Crea validar_edad.php:

<?php
       class ValidadorEdad {
           public function validar($edad) {
               try {
                   if (!is_numeric($edad)) {
                       throw new Exception("La edad debe ser un número");
                   }
                   if ($edad < 1 || $edad > 100) {
                       throw new Exception("La edad debe estar entre 1 y 100 años");
                   }
                   echo "Edad válida: $edad años<br>";
               } catch (Exception $e) {
                   echo "Error: " . $e->getMessage() . "<br>";
               } finally {
                   echo "Validación terminada<br>";
               }
           }
       }

       $validador = new ValidadorEdad();
       $validador->validar(25);
       $validador->validar(0);
       $validador->validar(150);
       $validador->validar("veinte");
   ?>

Ejecuta en localhost/curso_php8/ y juega con los valores. Verás algo como:

Edad válida: 25 años
Validación terminada
Error: La edad debe estar entre 1 y 100 años
Validación terminada
Error: La edad debe estar entre 1 y 100 años
Validación terminada
Error: La edad debe ser un número
Validación terminada

Consejos para no enredarte

• Lanza con sentido: Usa throw solo para errores que merezcan interrumpir el flujo.
• Captura específica: Puedes usar múltiples catch para diferentes tipos de excepciones (como InvalidArgumentException).
• Usa finally sabiamente: Ideal para cerrar conexiones o limpiar recursos.
• Mensajes claros: Asegúrate de que $e->getMessage() explique bien el problema.

¡A por más control!

¡Gran trabajo! Ahora las excepciones son tu escudo para manejar errores sin que tu app se rompa. En la próxima lección, veremos atributos y métodos estáticos para compartir datos sin instanciar clases. Si algo no te queda claro, déjame un comentario.

Lo que aprendiste hoy:

• Qué son: Objetos que representan errores para controlarlos con estilo.
• try, catch, finally: Tus herramientas para atrapar y gestionar excepciones.
• Ejemplos vivos: Hiciste divisiones y validaciones como crack.
• Practicaste: Validaste edades con excepciones como pro.
• Tip del pro: Usa mensajes claros en tus excepciones para debuguear fácil.