Cuando escribes código, los errores son inevitables, pero lo que realmente importa es cómo los manejas. En PHP, las excepciones personalizadas son una herramienta poderosa para controlar y comunicar errores específicos en tu aplicación. Hoy aprenderás cómo usarlas y sacarles el máximo provecho.

¿Qué son las excepciones personalizadas?

Las excepciones personalizadas te permiten definir tus propios tipos de errores, añadiendo contexto y claridad al manejo de situaciones excepcionales. Son útiles cuando necesitas diferenciar errores específicos dentro de tu aplicación.

Cómo crear una excepción personalizada

Para crear una excepción personalizada, simplemente extiende la clase base Exception.

Ejemplo:

class SinEnergiaException extends Exception {
    public function __construct(string $mensaje, int $energiaRestante) {
        $mensaje .= " Energía restante: {$energiaRestante}.";
        parent::__construct($mensaje);
    }
}

Aquí creamos una excepción SinEnergiaException que añade información extra sobre la energía restante.

Lanzando una excepción personalizada

Puedes usar throw para lanzar tu excepción personalizada cuando ocurra un error específico.

Ejemplo:

class Pokemon {
    private int $energia;

    public function __construct(int $energia) {
        $this->energia = $energia;
    }

    public function atacar(): string {
        if ($this->energia <= 0) {
            throw new SinEnergiaException("No puedes atacar", $this->energia);
        }
        $this->energia -= 10;
        return "¡Ataque realizado! Energía restante: {$this->energia}";
    }
}

Si el Pokémon no tiene suficiente energía, se lanza una SinEnergiaException.

Capturando excepciones personalizadas

Para manejar estas excepciones, usa un bloque try-catch.

Ejemplo:

$pikachu = new Pokemon(5);

try {
    echo $pikachu->atacar(); // Lanza excepción
    echo $pikachu->atacar(); // Sin energía
} catch (SinEnergiaException $e) {
    echo "Error: " . $e->getMessage();
}

La salida sería:

Error: No puedes atacar. Energía restante: 0.

Esto asegura que el programa no se detenga abruptamente y que puedas manejar el error de forma controlada.

Jerarquía de excepciones: ¡Captura lo que necesitas!

Puedes usar una jerarquía de excepciones para manejar diferentes tipos de errores.

Ejemplo:

class PokemonException extends Exception {}
class SinEnergiaException extends PokemonException {}
class AtaqueInvalidoException extends PokemonException {}

class Pokemon {
    private int $energia;

    public function __construct(int $energia) {
        $this->energia = $energia;
    }

    public function atacar(string $ataque): string {
        if ($this->energia <= 0) {
            throw new SinEnergiaException("No puedes atacar", $this->energia);
        }
        if ($ataque !== "Impactrueno") {
            throw new AtaqueInvalidoException("Ataque no reconocido: {$ataque}");
        }
        $this->energia -= 10;
        return "¡{$ataque} realizado! Energía restante: {$this->energia}";
    }
}

try {
    $pikachu = new Pokemon(10);
    echo $pikachu->atacar("Llamarada"); // Lanza AtaqueInvalidoException
} catch (AtaqueInvalidoException $e) {
    echo "Error de ataque: " . $e->getMessage();
} catch (SinEnergiaException $e) {
    echo "Error de energía: " . $e->getMessage();
} catch (PokemonException $e) {
    echo "Error general: " . $e->getMessage();
}

Esto organiza los errores en niveles, permitiendo capturar y manejar excepciones específicas o generales según sea necesario.

Buenas prácticas para excepciones personalizadas

• No abuses de las excepciones para errores triviales.
• Proporciona información adicional en el mensaje de la excepción.
• Explica en la documentación de tu código cuándo y por qué se lanza cada excepción.
• Si algo no es un Exception, no lo lances.