Introduction

## Regras Críticas - Escolhendo entre LogicException e RuntimeException em PHP

Você já se viu depurando uma aplicação PHP e incerto se uma LogicException ou RuntimeException é a escolha certa? Este guia rápido esclarece a distinção. Você aprenderá como essas exceções, ambas parte da hierarquia de exceções do PHP, sinalizam diferentes tipos de problemas. Compreender quando lançar cada uma—erros de lógica versus problemas de tempo de execução—melhorará a clareza do código, a capacidade de manutenção e ajudará você a escrever aplicações mais robustas. Vamos mergulhar!

Compreendendo as Exceções SPL do PHP e Seu Propósito

A Biblioteca Padrão do PHP (SPL) fornece LogicException e RuntimeException como classes base para exceções personalizadas, cada uma significando diferentes condições de erro. LogicException destina-se a situações que representam falhas na lógica do programa – erros que não deveriam ocorrer se o código estiver escrito corretamente. Essas exceções indicam um bug que requer correção do código.

Em contraste, RuntimeException lida com erros que só podem ser detectados durante a execução do programa. Estes são problemas que surgem durante o tempo de execução e não são previsíveis ou evitáveis apenas por meio de análise estática ou design de código. Eles representam condições que são possíveis, embora indesejáveis, resultados da operação do programa.

Ao criar classes de exceção personalizadas, como PageNotFoundException, considere cuidadosamente a natureza do erro. Se o erro indica um erro lógico fundamental, LogicException é a base apropriada. Se for uma condição de tempo de execução, RuntimeException é mais adequado.

<?php

// Custom exception class for logic errors in application flow
class LogicException extends Exception {
    // Constructor to set custom error message
    public function __construct($message, $code = 0, Throwable $previous = null) {
        parent::__construct($message, $code, $previous);
    }
}

// Custom exception class for runtime errors that are not logic issues
class RuntimeException extends Exception {
    // Constructor to set custom error message
    public function __construct($message, $code = 0, Throwable $previous = null) {
        parent::__construct($message, $code, $previous);
    }
}

// Custom exception class for page not found errors
class PageNotFoundException extends Exception {
    // Constructor to set custom error message
    public function __construct($message, $code = 404, Throwable $previous = null) {
        parent::__construct($message, $code, $previous);
    }
}

// Example usage of the custom exceptions
try {
    // Simulate a logic error in application flow
    throw new LogicException("Invalid operation attempted");

} catch (LogicException $e) {
    echo "Caught LogicException: " . $e->getMessage() . "\n";
}

try {
    // Simulate a runtime error that is not a logic issue
    throw new RuntimeException("An unexpected error occurred");

} catch (RuntimeException $e) {
    echo "Caught RuntimeException: " . $e->getMessage() . "\n";
}

try {
    // Simulate a page not found error
    throw new PageNotFoundException("Page not found", 404);

} catch (PageNotFoundException $e) {
    echo "Caught PageNotFoundException: " . $e->getMessage() . "\n";
}
?>

Exceção Lógica vs Exceção em Tempo de Execução: Casos de Uso e Exemplos

A distinção entre LogicException e RuntimeException em PHP esclarece a natureza dos erros encontrados durante a execução do programa. LogicException sinaliza uma falha irrecuperável no design ou lógica do programa. Estes erros representam situações que não deveriam ocorrer se o código estiver funcionando corretamente e requerem uma correção direta no próprio código subjacente.

Em contrapartida, RuntimeException indica erros que só podem ser detectados durante o tempo de execução. Estes erros não são necessariamente devidos a lógica defeituosa, mas surgem de condições que só são aparentes enquanto o programa está em execução. Eles representam situações em que o programa pode continuar, talvez com funcionalidade degradada, mas o erro necessita de atenção.

A escolha entre os dois depende da natureza do erro. Se um erro aponta para um problema fundamental de design que impede o comportamento esperado, LogicException é apropriado. Se o erro é dependente de condições de tempo de execução, RuntimeException é a escolha mais adequada.

<?php

// Define a custom exception class for page not found errors
class PageNotFoundException extends RuntimeException {
    public function __construct($message = "Page not found", $code = 404, Exception $previous = null) {
        parent::__construct($message, $code, $previous);
    }
}

// Function to simulate fetching a page
function fetchPage($pageId) {
    // Simulate a database lookup
    $pages = [
        'home' => 'Welcome to the home page',
        'about' => 'This is the about page'
    ];

    if (!isset($pages[$pageId])) {
        throw new PageNotFoundException("The page with ID '$pageId' does not exist.");
    }

    return $pages[$pageId];
}

// Example usage
try {
    // Attempt to fetch a non-existent page
    echo fetchPage('contact');
} catch (PageNotFoundException $e) {
    // Handle the exception by logging and displaying an error message
    error_log($e->getMessage());
    http_response_code($e->getCode());
    echo "Error: " . $e->getMessage();
}
?>

Escolhendo a Classe Base Certa para Exceções Personalizadas

Ao projetar exceções personalizadas em PHP, escolher entre LogicException e RuntimeException é crucial para o tratamento de erros e depuração adequados. LogicException sinaliza uma falha no design ou na lógica do programa – uma situação que não deveria ocorrer se o código estiver funcionando corretamente. Essas exceções normalmente indicam um erro de programação que requer modificação do código.

RuntimeException, por outro lado, representa erros detectáveis apenas durante a execução do programa. São situações que poderiam concebivelmente acontecer apesar da lógica correta do programa, frequentemente relacionadas a fatores externos ou condições de tempo de execução. Elas representam circunstâncias inesperadas que surgem enquanto o aplicativo está em execução.

Portanto, utilize LogicException para erros que representam bugs no seu código que precisam de correção. Utilize RuntimeException para condições que são válidas, embora inesperadas, ocorrências durante a operação do programa.

<?php

// Custom exception class for logic errors in application flow
class LogicException extends Exception {
    // Constructor to set custom error message
    public function __construct($message, $code = 0, Throwable $previous = null) {
        parent::__construct($message, $code, $previous);
    }
}

// Custom exception class for runtime errors that are not logic issues
class RuntimeException extends Exception {
    // Constructor to set custom error message
    public function __construct($message, $code = 0, Throwable $previous = null) {
        parent::__construct($message, $code, $previous);
    }
}

// Custom exception class for page not found errors
class PageNotFoundException extends Exception {
    // Constructor to set custom error message
    public function __construct($message, $code = 404, Throwable $previous = null) {
        parent::__construct($message, $code, $previous);
    }
}

// Example usage of the custom exceptions
try {
    // Simulate a logic error in application flow
    throw new LogicException("Invalid operation attempted");

} catch (LogicException $e) {
    echo "Caught LogicException: " . $e->getMessage() . "\n";

} catch (RuntimeException $e) {
    echo "Caught RuntimeException: " . $e->getMessage() . "\n";

} catch (PageNotFoundException $e) {
    echo "Caught PageNotFoundException: " . $e->getMessage() . "\n";
}

// Simulate a runtime error that is not a logic issue
try {
    // Attempt to access an undefined variable
    echo $undefinedVariable;

} catch (RuntimeException $e) {
    echo "Caught RuntimeException: " . $e->getMessage() . "\n";

} catch (LogicException $e) {
    echo "Caught LogicException: " . $e->getMessage() . "\n";

} catch (PageNotFoundException $e) {
    echo "Caught PageNotFoundException: " . $e->getMessage() . "\n";
}

// Simulate a page not found error
try {
    // Attempt to access a non-existent page
    throw new PageNotFoundException("Page not found");

} catch (PageNotFoundException $e) {
    echo "Caught PageNotFoundException: " . $e->getMessage() . "\n";

} catch (RuntimeException $e) {
    echo "Caught RuntimeException: " . $e->getMessage() . "\n";

} catch (LogicException $e) {
    echo "Caught LogicException: " . $e->getMessage() . "\n";
}
?>

Conclusion

Em PHP, escolher o tipo de exceção correto é crucial para um código sustentável. RuntimeException sinaliza problemas fora da lógica do programa, como falhas no acesso a arquivos, enquanto LogicException indica falhas no design do programa ou suposições incorretas. Selecionar a classe base apropriada — seja estendendo RuntimeException ou LogicException — comunica claramente a natureza do erro, auxiliando na depuração e melhorando a clareza do código.