Tipos de errores en PHP

En PHP, los errores pueden clasificarse en diferentes categorías según su naturaleza y el momento en que se producen. Comprender estos tipos de errores es fundamental para manejar adecuadamente las excepciones y mejorar la robustez de las aplicaciones.

Los errores de sintaxis (parse errors) ocurren cuando el intérprete de PHP no puede analizar el código debido a errores en la sintaxis. Esto suele deberse a un paréntesis o punto y coma faltante, o a una estructura incorrecta en el código. Por ejemplo:

<?php
echo "Hola mundo" // Falta el punto y coma al final

Al ejecutar este código, PHP generará un mensaje indicando el error de sintaxis y la línea donde se ha producido.

Los errores fatales suceden cuando PHP encuentra un problema que le impide continuar la ejecución del script. Un ejemplo común es intentar instanciar una clase que no existe o llamar a una función indefinida. Por ejemplo:

<?php
miFuncionInexistente();

PHP generará un error fatal indicando que la función no está definida y el script se detendrá inmediatamente.

Los avisos o warnings son errores menos graves. PHP los emite cuando encuentra algo inusual pero no detiene la ejecución del script. Un ejemplo es incluir un archivo que no existe con include():

<?php
include("archivo_que_no_existe.php");
echo "Este texto se mostrará a pesar del warning.\n";

A pesar del aviso, el script continuará ejecutándose y mostrará el mensaje.

Las notificaciones o notices son mensajes que indican condiciones que pueden ser problemáticas pero que no impiden la ejecución del script. Un caso común es acceder a una variable que no ha sido inicializada. Por ejemplo:

<?php
echo $variableNoDefinida;

PHP emitirá un notice indicando que la variable no está definida, pero el script seguirá funcionando.

Las excepciones son objetos que representan condiciones excepcionales que pueden ocurrir durante la ejecución de un programa. A diferencia de los errores, las excepciones pueden ser capturadas y manejadas mediante bloques try y catch, lo que permite controlar el flujo de la aplicación ante situaciones inesperadas. Por ejemplo:

<?php
throw new Exception("Ha ocurrido una excepción.\n");

Si no se captura la excepción con un bloque try-catch, PHP generará un error fatal. Las excepciones son fundamentales en la programación orientada a objetos para manejar errores de manera estructurada.

Los errores fatales recuperables (recoverable fatal errors), introducidos en PHP 7, ocurren cuando el código viola una restricción, como intentar asignar un valor de un tipo incorrecto a una variable con tipado estricto. Aunque son fatales, estos errores pueden capturarse mediante bloques try-catch utilizando el tipo Error. Por ejemplo:

<?php
function sumar(int $a, int $b)
{
    return $a + $b;
}
echo sumar("uno", "dos");

PHP generará un error de tipo, que puede ser capturado y manejado.

Comprender los diferentes tipos de errores en PHP es esencial para implementar un manejo de excepciones eficaz y garantizar aplicaciones más robustas y mantenibles.

Gestión de errores con try, catch y finally

El manejo de excepciones en PHP se realiza principalmente mediante los bloques try, catch y finally. Estos bloques permiten capturar y manejar errores de forma controlada, mejorando la robustez y seguridad de las aplicaciones.

El bloque try contiene el código que puede generar una excepción. Si ocurre una excepción dentro del bloque try, la ejecución se transfiere al primer bloque catch que coincida con el tipo de excepción lanzada. Por ejemplo:

<?php
try {
    $division = 10 / 0;
    echo "Resultado: $division\n";
} catch (DivisionByZeroError $e) {
    echo "Error: " . $e->getMessage() . "\n";
}

En este ejemplo, al intentar dividir por cero, se lanza una excepción de tipo DivisionByZeroError, que es capturada por el bloque catch correspondiente. La función getMessage() proporciona el mensaje asociado a la excepción.

Es posible capturar múltiples tipos de excepciones utilizando varios bloques catch. PHP evaluará cada bloque catch en orden hasta encontrar uno que coincida con el tipo de la excepción. Por ejemplo:

<?php
try {
    $archivo = fopen("datos.txt", "r");
    if (!$archivo) {
        throw new Exception("No se puede abrir el archivo.\n");
    }
} catch (Exception $e) {
    echo "Excepción capturada: " . $e->getMessage();
} catch (Error $e) {
    echo "Error capturado: " . $e->getMessage();
}

Si se lanza una excepción de tipo Exception, será capturada por el primer bloque catch. Si ocurre un Error no previsto, será capturado por el segundo bloque catch.

El bloque finally se ejecuta siempre, independientemente de si se ha producido una excepción o no. Es útil para liberar recursos o realizar tareas de limpieza. Por ejemplo:

<?php
$conexion = null;
try {
    $conexion = new PDO($dsn, $usuario, $contraseña);
    // Operaciones con la base de datos
} catch (PDOException $e) {
    echo "Error de conexión: " . $e->getMessage() . "\n";
} finally {
    if ($conexion !== null) {
        $conexion = null;
        echo "Conexión cerrada.\n";
    }
}

En este caso, el bloque finally asegura que la conexión a la base de datos se cierra correctamente, incluso si ocurre una excepción durante las operaciones con la base de datos.

También es posible capturar excepciones genéricas utilizando Throwable, que es la interfaz base para Exception y Error. Por ejemplo:

<?php
try {
    // Código que puede lanzar una excepción o error
} catch (Throwable $t) {
    echo "Error o excepción capturada: " . $t->getMessage() . "\n";
}

El uso de Throwable permite manejar cualquier tipo de excepción o error que se pueda lanzar desde el bloque try.

Es importante utilizar try, catch y finally de manera adecuada para garantizar que los errores se manejan correctamente y que los recursos se liberan apropiadamente. Además, permite que el programa continúe ejecutándose de forma segura después de que ocurra una excepción.

Otro aspecto relevante es la posibilidad de anidar bloques try-catch para manejar excepciones en diferentes niveles de la aplicación. Por ejemplo:

<?php
try {
    try {
        // Código que puede generar una excepción
    } catch (Exception $e) {
        echo "Excepción interna: " . $e->getMessage() . "\n";
        throw $e; // Relanzar la excepción
    }
} catch (Exception $e) {
    echo "Excepción externa: " . $e->getMessage() . "\n";
}

En este ejemplo, la excepción se captura primero en el bloque catch interno, y luego se relanza con throw para ser capturada nuevamente en el bloque catch externo.

El manejo adecuado de excepciones con try, catch y finally es esencial para desarrollar aplicaciones fiables y mantenibles. Permite controlar el flujo del programa ante situaciones inesperadas y proporciona mecanismos para informar al usuario o al sistema de errores ocurridos durante la ejecución.

Creación de excepciones personalizadas

Además de las excepciones predefinidas que ofrece PHP, es posible crear excepciones personalizadas para manejar situaciones específicas de una aplicación. Esto permite representar de forma más precisa los errores que pueden ocurrir y proporciona un control más fino sobre el flujo del programa.

Para crear una excepción personalizada, se define una clase que extiende de la clase base Exception o de alguna de sus subclases. Al hacerlo, heredamos las propiedades y métodos de la clase Exception, como getMessage(), getCode(), getFile(), getLine(), entre otros. A continuación, se muestra un ejemplo básico:

<?php
class MiExcepcionPersonalizada extends Exception
{
    // Constructor personalizado opcional
    public function __construct($mensaje, $codigo = 0, Exception $anterior = null)
    {
        // Asegurarse de llamar al constructor padre
        parent::__construct($mensaje, $codigo, $anterior);
    }

    // Método personalizado para representar el objeto como una cadena
    public function __toString()
    {
        return __CLASS__ . ": [{$this->code}]: {$this->message}\n";
    }
}

En este ejemplo, MiExcepcionPersonalizada es una nueva clase de excepción que puede utilizarse para representar errores específicos. Al extender de Exception, se garantiza que la nueva clase se comportará como una excepción estándar de PHP.

Es posible agregar propiedades adicionales a la excepción personalizada para almacenar información relevante sobre el error. Por ejemplo:

<?php
class ExcepcionDeArchivo extends Exception
{
    private $nombreArchivo;

    public function __construct($mensaje, $nombreArchivo, $codigo = 0, Exception $anterior = null)
    {
        $this->nombreArchivo = $nombreArchivo;
        parent::__construct($mensaje, $codigo, $anterior);
    }

    // Método para obtener el nombre del archivo relacionado con la excepción
    public function getNombreArchivo()
    {
        return $this->nombreArchivo;
    }
}

Esta clase ExcepcionDeArchivo almacena el nombre del archivo que causó el error, lo que permite acceder a esta información al manejar la excepción.

Al crear excepciones personalizadas, es común definir una jerarquía de excepciones para representar diferentes tipos de errores de manera estructurada. Por ejemplo:

<?php
// Excepción base para errores de base de datos
class ExcepcionBaseDeDatos extends Exception {}

// Excepción específica para errores de conexión
class ExcepcionDeConexion extends ExcepcionBaseDeDatos {}

// Excepción específica para errores en consultas
class ExcepcionDeConsulta extends ExcepcionBaseDeDatos {}

Esta jerarquía permite manejar de forma genérica todos los errores de base de datos o capturar excepciones específicas según sea necesario.

A continuación, se muestra un ejemplo práctico del uso de una excepción personalizada:

<?php
class DivisorCeroException extends Exception
{
    public function __construct($mensaje = "Error: División por cero.", $codigo = 0, Exception $anterior = null)
    {
        parent::__construct($mensaje, $codigo, $anterior);
    }
}

function dividir($dividendo, $divisor)
{
    if ($divisor == 0) {
        throw new DivisorCeroException();
    }
    return $dividendo / $divisor;
}

try {
    $resultado = dividir(10, 0);
    echo "Resultado: $resultado\n";
} catch (DivisorCeroException $e) {
    echo $e->getMessage() . "\n";
}

En este código, la función dividir() comprueba si el divisor es cero y, en ese caso, lanza una DivisorCeroException. Al capturar esta excepción específica, se puede manejar el error de manera adecuada sin afectar otras partes del programa.

También es posible integrar métodos adicionales que proporcionen más contexto sobre la excepción o que implementen lógica de recuperación. La creación de excepciones personalizadas mejora la legibilidad y el mantenimiento del código, ya que permite identificar y manejar errores específicos de la aplicación.

Es importante seguir algunas buenas prácticas al crear excepciones personalizadas:

• Extender siempre de la clase Exception o de una de sus subclases.
• Proporcionar mensajes de error claros y concisos.
• Evitar exponer información sensible en los mensajes de error.
• Utilizar nombres de clases que reflejen el tipo de error o condición excepcional.

Las excepciones personalizadas son una herramienta poderosa para mejorar el manejo de errores y hacer que las aplicaciones sean más robustas y fáciles de mantener.

Lanzamiento y captura de excepciones personalizadas

Una vez que hemos creado excepciones personalizadas, es fundamental saber cómo lanzarlas y capturarlas adecuadamente en nuestro código. Esto permite manejar situaciones específicas de error de una manera más controlada y proporciona una mayor claridad en el flujo de la aplicación.

Lanzamiento de excepciones personalizadas

Para lanzar una excepción personalizada, utilizamos la palabra clave throw seguida de una instancia de nuestra clase de excepción. Esto provoca que el flujo normal del programa se detenga y se busque un bloque catch que maneje el tipo de excepción lanzada. Por ejemplo:

<?php
class UsuarioNoEncontradoException extends Exception
{
    public function __construct($mensaje = "Usuario no encontrado.", $codigo = 0, Exception $anterior = null)
    {
        parent::__construct($mensaje, $codigo, $anterior);
    }
}

function obtenerUsuarioPorId($id)
{
    $usuarios = [
        1 => "Alice",
        2 => "Bob",
        3 => "Charlie"
    ];

    if (!array_key_exists($id, $usuarios)) {
        throw new UsuarioNoEncontradoException("El usuario con ID $id no existe.\n");
    }

    return $usuarios[$id];
}

En este ejemplo, la función obtenerUsuarioPorId lanza una excepción personalizada UsuarioNoEncontradoException si el ID proporcionado no existe en el array de usuarios.

Captura de excepciones personalizadas

Para capturar una excepción personalizada, utilizamos un bloque try-catch donde el bloque catch especifica el tipo de excepción que deseamos manejar. De esta forma, podemos definir distintas acciones según el tipo de error ocurrido. Por ejemplo:

<?php
try {
    $usuario = obtenerUsuarioPorId(5);
    echo "Usuario encontrado: $usuario\n";
} catch (UsuarioNoEncontradoException $e) {
    echo "Error: " . $e->getMessage();
} catch (Exception $e) {
    echo "Se ha producido un error inesperado: " . $e->getMessage();
}

En este código, intentamos obtener un usuario con ID 5, que no existe. Al lanzarse la excepción UsuarioNoEncontradoException, es capturada por el bloque catch correspondiente, y se muestra el mensaje de error personalizado.

Es importante notar que si hay varios bloques catch, PHP intentará capturar la excepción con el primer bloque que coincida con el tipo de la excepción lanzada. Por ello, es recomendable capturar primero las excepciones más específicas y luego las más genéricas.

Relanzamiento de excepciones

En algunas situaciones, puede ser útil relanzar una excepción después de haberla capturado, especialmente si necesitamos realizar alguna acción adicional antes de propagar el error. Para ello, utilizamos la palabra clave throw dentro del bloque catch. Por ejemplo:

<?php
try {
    $usuario = obtenerUsuarioPorId(5);
    echo "Usuario encontrado: $usuario\n";
} catch (UsuarioNoEncontradoException $e) {
    echo "Registro de error: " . $e->getMessage();
    throw $e; // Relanzamos la excepción
} catch (Exception $e) {
    echo "Se ha producido un error inesperado: " . $e->getMessage();
}

Al relanzar la excepción, podemos permitir que niveles superiores de la aplicación manejen el error o que se tomen medidas adicionales.

Uso de jerarquías de excepciones

Al definir excepciones personalizadas, es común crear una jerarquía que refleje diferentes niveles de detalle en los errores. Esto facilita la captura de grupos de excepciones relacionadas. Por ejemplo:

<?php
class AplicacionException extends Exception {}

class UsuarioException extends AplicacionException {}
class ProductoException extends AplicacionException {}

class UsuarioNoEncontradoException extends UsuarioException {}
class ProductoNoEncontradoException extends ProductoException {}

Con esta estructura, podemos capturar excepciones de forma específica o general, según nuestras necesidades:

<?php
try {
    // Código que puede lanzar diferentes excepciones
} catch (UsuarioNoEncontradoException $e) {
    echo "Error de usuario: " . $e->getMessage();
} catch (AplicacionException $e) {
    echo "Error de la aplicación: " . $e->getMessage();
} catch (Exception $e) {
    echo "Error no manejado: " . $e->getMessage();
}

De esta manera, primero capturamos las excepciones más específicas y luego las más generales, permitiendo un manejo más flexible de los errores.

Agregando información adicional a las excepciones

Al lanzar excepciones personalizadas, podemos incluir información relevante que ayude en el diagnóstico del error. Esto se logra extendiendo las propiedades de la excepción o agregando métodos personalizados. Por ejemplo:

<?php
class ValidacionException extends Exception
{
    private $errores;

    public function __construct($errores, $mensaje = "Error de validación.", $codigo = 0, Exception $anterior = null)
    {
        $this->errores = $errores;
        parent::__construct($mensaje, $codigo, $anterior);
    }

    public function getErrores()
    {
        return $this->errores;
    }
}

function validarDatos($datos)
{
    $errores = [];

    if (empty($datos['nombre'])) {
        $errores[] = "El campo 'nombre' es obligatorio.";
    }

    if (!filter_var($datos['email'], FILTER_VALIDATE_EMAIL)) {
        $errores[] = "El correo electrónico no es válido.";
    }

    if (!empty($errores)) {
        throw new ValidacionException($errores);
    }

    return true;
}

Al capturar esta excepción, podemos acceder a la lista de errores de validación:

<?php
$datos = ['nombre' => '', 'email' => 'correo_invalido'];

try {
    validarDatos($datos);
    echo "Datos válidos.\n";
} catch (ValidacionException $e) {
    echo "Se encontraron los siguientes errores:\n";
    foreach ($e->getErrores() as $error) {
        echo "- $error\n";
    }
}

Este enfoque proporciona una forma estructurada de manejar errores complejos y comunicar información detallada.

Excepciones anidadas

PHP permite manejar excepciones anidadas utilizando el tercer parámetro del constructor de la clase Exception. Esto es útil cuando una excepción es causada por otra, y deseamos preservar la cadena de errores. Por ejemplo:

<?php
class ServicioException extends Exception {}

function servicioExterno()
{
    try {
        // Código que puede lanzar una excepción
        throw new Exception("Fallo en el servicio externo.");
    } catch (Exception $e) {
        throw new ServicioException("Error al comunicarse con el servicio externo.", 0, $e);
    }
}

try {
    servicioExterno();
} catch (ServicioException $e) {
    echo "Error: " . $e->getMessage() . "\n";
    echo "Causa original: " . $e->getPrevious()->getMessage() . "\n";
}

Al utilizar el método getPrevious(), podemos acceder a la excepción original que causó el error, lo que facilita el depurado y la resolución de problemas.

Beneficios del lanzamiento y captura de excepciones personalizadas

El uso adecuado de excepciones personalizadas mejora la legibilidad y el mantenimiento del código. Permite:

• Identificar rápidamente el origen y tipo de error.
• Separar la lógica de negocio de la gestión de errores.
• Proporcionar feedback más claro y específico al usuario o al sistema.
• Facilitar la escalabilidad al añadir nuevos tipos de excepciones.

En resumen, el lanzamiento y captura de excepciones personalizadas es una práctica esencial en la programación orientada a objetos en PHP, que contribuye a desarrollar aplicaciones más robustas y profesionales.

Registro y log de errores

El registro y log de errores es una práctica esencial para el mantenimiento y depuración de aplicaciones en PHP. Al registrar los errores que ocurren durante la ejecución, podemos analizar y solucionar problemas de manera más eficiente, incluso cuando no estamos presentes para observarlos en tiempo real.

PHP permite configurar el comportamiento del registro de errores mediante directivas en el archivo php.ini. Algunas de las configuraciones más importantes son:

• error_reporting: establece el nivel de errores que serán reportados. Por ejemplo, para reportar todos los errores y advertencias, se puede configurar de la siguiente manera:

  error_reporting = E_ALL

• log_errors: activa o desactiva el registro de errores. Para habilitarlo, se debe establecer en On:

  log_errors = On

• error_log: especifica la ruta del archivo donde se almacenarán los logs de errores. Por ejemplo:

  error_log = /var/log/php_errors.log

Con estas configuraciones, PHP registrará todos los errores en el archivo especificado, lo que facilita su posterior análisis.

La función error_log() permite enviar mensajes de error directamente al sistema de registro definido. Esta función es útil para registrar eventos personalizados o información de depuración. Su sintaxis básica es:

<?php
error_log("Mensaje de error personalizado.\n");

El mensaje proporcionado se almacenará en el archivo definido por la directiva error_log en php.ini. También es posible especificar el destino del mensaje utilizando los parámetros opcionales de la función.

Supongamos que queremos registrar un error cuando una operación no se puede completar:

<?php
function procesarDatos($datos)
{
    if (empty($datos)) {
        error_log("Error: Los datos proporcionados están vacíos.\n");
        throw new Exception("No se pueden procesar datos vacíos.\n");
    }
    // Procesamiento de datos
    echo "Datos procesados correctamente.\n";
}

try {
    procesarDatos([]);
} catch (Exception $e) {
    echo $e->getMessage();
}

En este ejemplo, si el array $datos está vacío, se registra un mensaje de error y se lanza una excepción. El mensaje se almacenará en el archivo de log configurado, y la excepción podrá ser manejada adecuadamente.

Cuando se capturan excepciones, es una buena práctica registrar la información relevante para facilitar su diagnóstico. Podemos utilizar error_log() dentro del bloque catch para almacenar detalles de la excepción:

<?php
try {
    // Código que puede lanzar una excepción
    throw new Exception("Ha ocurrido un error inesperado.\n");
} catch (Exception $e) {
    error_log("Excepción capturada: " . $e->getMessage());
    echo "Error: " . $e->getMessage();
}

Esto asegurará que cada vez que se produzca una excepción, quede constancia en el log, incluyendo el mensaje y, si es necesario, información adicional como el archivo y la línea donde ocurrió:

<?php
error_log("Excepción en " . $e->getFile() . " línea " . $e->getLine() . ": " . $e->getMessage());

PHP permite definir un manejador de errores personalizado utilizando la función set_error_handler(). Esto nos da control total sobre cómo se registran y manejan los errores:

<?php
function miManejadorDeErrores($numero, $mensaje, $archivo, $linea)
{
    $log = "Error [$numero] en $archivo línea $linea: $mensaje\n";
    error_log($log);
    // Podemos decidir si detener la ejecución o continuar
    // exit();
}

set_error_handler("miManejadorDeErrores");

Con este manejador, cualquier error que ocurra en el script será procesado por nuestra función, permitiendo un registro más detallado o acciones específicas.

Para aplicaciones más complejas, es recomendable utilizar bibliotecas especializadas como Monolog, que ofrecen funcionalidades avanzadas para el registro de errores y eventos. Monolog es compatible con la especificación PSR-3, lo que asegura interoperabilidad y buenas prácticas.

Para instalar Monolog, se puede utilizar Composer:

composer require monolog/monolog

Y luego, en el código PHP:

<?php
use Monolog\Logger;
use Monolog\Handler\StreamHandler;

$log = new Logger('mi_aplicacion');
$log->pushHandler(new StreamHandler(__DIR__ . '/logs/app.log', Logger::WARNING));

// Añadir registros
$log->warning("Esto es una advertencia.\n");
$log->error("Esto es un error.\n");

Monolog permite enviar registros a múltiples destinos, aplicar formatos personalizados y gestionar niveles de severidad con mayor flexibilidad.

Al utilizar el servidor web integrado de PHP con php -S localhost:8000, es importante asegurarse de que los errores se registren adecuadamente. Por defecto, el servidor puede mostrar los errores en pantalla, lo cual no es recomendable en un entorno de producción. Es preferible configurar display_errors a Off y log_errors a On en php.ini o mediante las opciones -d al iniciar el servidor:

php -S localhost:8000 -d display_errors=Off -d log_errors=On

De esta manera, los errores no se mostrarán al usuario final, pero se registrarán para su revisión.

Es posible controlar el nivel de errores registrados ajustando la directiva error_reporting. Los niveles disponibles incluyen:

• E_ERROR: errores fatales en tiempo de ejecución.
• E_WARNING: advertencias en tiempo de ejecución (no fatales).
• E_PARSE: errores de compilación.
• E_NOTICE: notificaciones de tiempo de ejecución.
• E_ALL: todos los errores y advertencias.

Por ejemplo, para registrar solo errores y advertencias, se puede configurar:

error_reporting = E_ERROR | E_WARNING

Buenas prácticas en el registro de errores incluyen:

• No exponer información sensible: asegurarse de que los mensajes de error no revelen detalles confidenciales del sistema o la aplicación.
• Registrar información relevante: incluir detalles como la fecha y hora, el contexto del error y datos adicionales que puedan ayudar en el diagnóstico.
• Gestionar el tamaño de los logs: implementar rotación de logs para evitar que los archivos de registro crezcan indefinidamente.
• Monitorear los logs regularmente: revisar los registros periódicamente para detectar y solucionar problemas oportunamente.
• Utilizar niveles de severidad: clasificar los mensajes según su importancia para priorizar la atención a los problemas críticos.

PHP también puede enviar mensajes al syslog del sistema, lo cual es útil en entornos donde se centraliza la gestión de logs:

<?php
error_log("Mensaje al syslog.\n", 0);

O configurando error_log en php.ini:

error_log = syslog

Con esta configuración, los mensajes de error se enviarán al sistema de registro de eventos del sistema operativo, permitiendo una integración con herramientas de monitoreo y análisis.

Mejores prácticas en manejo de errores

Implementar un manejo de errores eficaz es fundamental para desarrollar aplicaciones robustas y fiables en PHP. A continuación, se presentan una serie de mejores prácticas que ayudan a gestionar las excepciones de manera adecuada y a mantener un código limpio y mantenible.

Una de las recomendaciones clave es lanzar excepciones únicamente para situaciones excepcionales y no para controlar el flujo normal del programa. Las excepciones deben utilizarse para condiciones inesperadas que el código no pueda manejar de forma rutinaria. Por ejemplo, si se espera que una función devuelva false en circunstancias normales, es preferible manejar ese caso en lugar de lanzar una excepción.

Es esencial capturar únicamente las excepciones que se pueden manejar adecuadamente. Evitar capturar todas las excepciones con un bloque catch (Exception $e) sin procesarlas correctamente, ya que esto puede ocultar errores y dificultar el depurado. En su lugar, capturar excepciones específicas y proporcionar soluciones o mensajes útiles al usuario.

Utilizar excepciones personalizadas para representar errores específicos de la aplicación mejora la claridad y permite un manejo más preciso de los errores. Al definir una jerarquía de excepciones acorde con la lógica del dominio, se facilita la captura y gestión de condiciones particulares. Por ejemplo, crear una excepción ValidacionException para errores de validación de datos.

Implementar un manejador global de excepciones no capturadas mediante set_exception_handler() ayuda a controlar y registrar errores inesperados en un solo punto. Esto permite centralizar la lógica de manejo de errores y asegurar que todas las excepciones que no se hayan capturado previamente sean tratadas de manera coherente.

<?php
function manejadorGlobalDeExcepciones($e)
{
    error_log("Excepción no capturada: " . $e->getMessage());
    http_response_code(500);
    echo "Ha ocurrido un error en el servidor.\n";
}

set_exception_handler('manejadorGlobalDeExcepciones');

Es recomendable evitar el uso del operador de control de errores @, ya que suprime los mensajes de error y puede dificultar la detección y resolución de problemas. En lugar de suprimir errores, es preferible manejarlos adecuadamente mediante bloques try-catch o comprobaciones previas.

Al trabajar con recursos externos, como conexiones a bases de datos o archivos, es crucial liberar los recursos en bloques finally o mediante estructuras que aseguren su correcta liberación. Esto previene fugas de memoria y garantiza el buen funcionamiento de la aplicación a largo plazo.

<?php
$archivo = null;
try {
    $archivo = fopen('datos.txt', 'r');
    // Procesar el archivo
} catch (Exception $e) {
    echo "Error al procesar el archivo: " . $e->getMessage() . "\n";
} finally {
    if ($archivo) {
        fclose($archivo);
    }
}

Es fundamental no exponer información sensible en los mensajes de error que se muestran al usuario. En entornos de producción, configurar display_errors a Off y log_errors a On para evitar que detalles técnicos se muestren públicamente. Los mensajes de error deben ser genéricos de cara al usuario final, pero detallados en los logs para facilitar la depuración.

Adoptar el tipado estricto y las declaraciones de tipos en parámetros y valores de retorno ayuda a detectar errores en tiempo de ejecución y mejora la claridad del código. Para activar el modo estricto, se puede declarar al inicio del script:

<?php
declare(strict_types=1);

// Función con tipado estricto
function sumar(int $a, int $b): int
{
    return $a + $b;
}

Es importante validar y sanitizar todas las entradas del usuario para prevenir errores y vulnerabilidades de seguridad. Utilizar funciones como filter_var() y htmlspecialchars() garantiza que los datos sean seguros y estén en el formato esperado antes de procesarlos.

Al registrar errores, emplear un sistema de logging estructurado que facilite el análisis y monitoreo. Incluir información contextual, como identificadores de usuarios o solicitudes, puede ser de gran ayuda para diagnosticar problemas. Herramientas como Monolog permiten registrar eventos con distintos niveles de severidad y destinos.

<?php
use Monolog\Logger;
use Monolog\Handler\StreamHandler;

$log = new Logger('aplicacion');
$log->pushHandler(new StreamHandler(__DIR__.'/logs/errores.log', Logger::ERROR));

try {
    // Código que puede generar una excepción
} catch (Exception $e) {
    $log->error('Error capturado', ['mensaje' => $e->getMessage(), 'traza' => $e->getTraceAsString()]);
    echo "Ha ocurrido un error.\n";
}

Seguir los estándares de codificación recomendados, como PSR-12, contribuye a la legibilidad y mantenimiento del código. Además, adherirse a las PSR-3 para logging y PSR-4 para autoloading garantiza la compatibilidad y facilita la integración con otras bibliotecas y frameworks.

Mantener los bloques de try-catch tan pequeños como sea necesario ayuda a aislar y manejar las excepciones específicamente donde ocurren. Evitar envolver grandes porciones de código en un único bloque try, ya que dificulta identificar el origen exacto de los errores y puede llevar a manejos inapropiados.

Es aconsejable documentar las excepciones que pueden ser lanzadas por funciones y métodos utilizando PHPDoc. Esto permite a otros desarrolladores comprender qué excepciones deben manejar al utilizar el código.

<?php
/**
 * Divide dos números.
 *
 * @param float $dividendo El número a dividir.
 * @param float $divisor El número por el que se divide.
 * @return float El resultado de la división.
 * @throws DivisionPorCeroException Si el divisor es cero.
 */
function dividir($dividendo, $divisor)
{
    if ($divisor == 0) {
        throw new DivisionPorCeroException("El divisor no puede ser cero.");
    }
    return $dividendo / $divisor;
}

Al manejar excepciones, es buena práctica no dejar bloques catch vacíos. Silenciar excepciones sin ninguna acción puede ocultar errores críticos y llevar a comportamientos inesperados. Si una excepción se ignora intencionalmente, se debe justificar y, preferiblemente, registrar.

Evitar el uso de excepciones como control de flujo para situaciones previsibles. Por ejemplo, en lugar de utilizar excepciones para indicar que un usuario no ha sido encontrado, puede retornarse null o false, y manejar esa condición de forma normal.

Implementar pruebas unitarias y de integración que incluyan escenarios de fallo y aseguren que las excepciones se lanzan y manejan correctamente. Esto garantiza que el manejo de errores funcione según lo previsto y ayuda a mantener la calidad del código a medida que evoluciona.

Considerar la reutilización de excepciones estándar antes de crear nuevas. PHP proporciona una variedad de excepciones listas para usar, como InvalidArgumentException, RuntimeException, LogicException, entre otras. Utilizarlas cuando sean apropiadas mejora la consistencia y comprensión del código.

Es necesario propagar las excepciones cuando el nivel actual no puede manejarlas adecuadamente. Esto permite que niveles superiores tomen decisiones informadas sobre cómo tratar el error, ya sea mostrando un mensaje al usuario, intentando una recuperación o finalizando la aplicación de forma segura.

<?php
function procesarOrden($orden)
{
    try {
        validarOrden($orden);
        guardarOrden($orden);
    } catch (ValidacionException $e) {
        // Manejo específico de errores de validación
        throw $e;
    } catch (Exception $e) {
        // Registro y propagación de otras excepciones
        error_log("Error al procesar la orden: " . $e->getMessage());
        throw $e;
    }
}

Finalmente, es vital actualizar y revisar periódicamente el manejo de errores a medida que la aplicación crece y cambia. Refactorizar el código para incorporar nuevas prácticas y eliminar manejos obsoletos contribuye a la salud general del software.

Siguiendo estas mejores prácticas en manejo de errores, se mejora la calidad, seguridad y confiabilidad de las aplicaciones PHP, proporcionando una mejor experiencia tanto para los desarrolladores como para los usuarios finales.