Manipulando erros em classes PHP

Manipular erros em PHP é extremamente importante, já que eles podem ajudar o desenvolvedor a resolver problemas que ele provavelmente não tenha visto no momento da escrita do código. Encontrar um erro é extremamente simples quando estamos falando em PHP, o interpretador da linguagem especifica qual foi o erro, em qual arquivo e qual a linha o mesmo ocorreu, ou seja, você não precisa vasculhar o código inteiro para saber onde um erro ocorreu.

Veja algumas categorias de erros comuns em programação:

  • Erros de Sintaxe: Normalmente ocorrem quando o desenvolvedor escreve algo de maneira incorreta. Em grande maioria dos casos, é um erro de digitação criado involuntariamente.
  • Erros de Semântica: Erros de semântica ocorrem quando o desenvolvedor cria um código que pode ser executado corretamente, porém, por algum motivo não pensado por ele, acontece o erro e está envolvido com seu código.
  • Erros de Lógica: Erros de lógica ocorrem quando o desenvolvedor escreve algo correto, porém, a lógica não é válida. Por exemplo, trocar um operador por outro e esperar que o interpretador compreenda.
  • Erros de ambiente: Erros de ambiente são relacionados à linguagem ou ao servidor em si. Normalmente fogem ao escopo do que o desenvolvedor pode fazer, sobrando para o Administrador do servidor.

Especificamente em PHP, existem vários níveis de erros que podem ser reportados. Vamos analisar melhor abaixo.

Níveis de erros em PHP

Cada erro tem seu nível e severidade, alguns podem apenas apresentar uma mensagem, outros podem fazer com que o código pare de ser executado.

Veja na tabela abaixo os tipos de erros que podemos encontrar em PHP:

Erros e Logs
Valor Constante Descrição
1 E_ERROR (integer) Erros fatais em tempo de execução. Estes indicam erros que não podem ser recuperados, como problemas de alocação de memória. A execução do script é interrompida.
2 E_WARNING (integer) Avisos em tempo de execução (erros não fatais). A execução do script não é interrompida.
4 E_PARSE (integer) Erro em tempo de compilação. Erros gerados pelo interpretador.
8 E_NOTICE (integer) Notícia em tempo de execução. Indica que o script encontrou alguma coisa que pode indicar um erro, mas que também possa acontecer durante a execução normal do script.
16 E_CORE_ERROR (integer) Erro fatal que acontece durante a inicialização do PHP. Este é parecido com E_ERROR, exceto que é gerado pelo núcleo do PHP.
32 E_CORE_WARNING (integer) Avisos (erros não fatais) que aconteçam durante a inicialização do PHP. Este é parecido com E_WARNING, exceto que é gerado pelo núcleo do PHP.
64 E_COMPILE_ERROR (integer) Erro fatal em tempo de compilação. Este é parecido com E_ERROR, exceto que é gerado pelo Zend Scripting Engine.
128 E_COMPILE_WARNING (integer) Aviso em tempo de compilação. Este é parecido com E_WARNING, exceto que é gerado pelo Zend Scripting Engine.
256 E_USER_ERROR (integer) Erro gerado pelo usuário. Este é parecido com E_ERROR, exceto que é gerado pelo código PHP usando a função trigger_error().
512 E_USER_WARNING (integer) Aviso gerado pelo usuário. Este é parecido com E_WARNING, exceto que é gerado pelo código PHP usando a função trigger_error().
1024 E_USER_NOTICE (integer) Notícia gerada pelo usuário. Este é parecido com E_NOTICE, exceto que é gerado pelo código PHP usando a função trigger_error().
2048 E_STRICT (integer) Notícias em tempo de execução. Permite ao PHP sugerir mudanças ao seu código as quais irão assegurar melhor interoperabilidade e compatibilidade futura do seu código.
4096 E_RECOVERABLE_ERROR (integer) Erro fatal capturável. Indica que um erro provavelmente perigoso aconteceu, mas não deixou o Engine em um estado instável. Se o erro não for pego por um manipulador definido pelo usuário (veja também set_error_handler()), a aplicação é abortada como se fosse um E_ERROR.
8192 E_DEPRECATED (integer) Avisos em tempo de execução. Habilite-o para receber avisos sobre código que não funcionará em futuras versões.
16384 E_USER_DEPRECATED (integer) Mensagem de aviso gerado pelo usuário. Este é como um E_DEPRECATED, exceto que é gerado em código PHP usando a função trigger_error().
30719 E_ALL (integer) Todos erros e avisos, como suportado, exceto de nível E_STRICT no PHP < 6.

A tabela acima está disponível no próprio manual do PHP.

Os tipos de erros da tabela acima devem estar ativos para que você possa vê-los. Para ativar, você pode alterar seu arquivo php.ini:

error_reporting = E_ALL

Você também pode utilizar opções diretamente no seu código. Por exemplo:

<?php
// Mostra todos os erros
error_reporting(E_ALL);
ini_set("display_errors", 1); 
?>

O trecho acima mostra todos os erros que seu código tiver. Se quiser ocultar todos os erros, o que não é recomendado que faça em seu ambiente de desenvolvimento, mude para:

<?php
// Oculta todos os erros
 error_reporting(0);
ini_set("display_errors", 0); 
?>

Você também pode criar um arquivo de log e salvar este arquivo no local que preferir. Para isso, é possível fazer o seguinte (também no código):

ini_set("error_log", "nome_do_arquivo.log");

E você vai ver todos os erros do seu código salvos em um arquivo de texto que poderá ser acessado posteriormente para análise.

Criando seus próprios erros em PHP

Se você está seguindo nosso curso de PHP gratuito desde o início, provavelmente já deve ter visto uma mensagem de erro do PHP em seu navegador. Isso acontece a todo o momento, com todos os desenvolvedores.

Porém, e se eu quiser criar meu próprio erro para exibir na tela se algo de errado ocorrer? Simples, utilize trigger_error, veja:

<?php
// Número inicial
$numero = 100;

// Verifica se 101 é maior que 100
if ( 101 > $numero ) {
	trigger_error ( "O número não pode ser maior que $numero", E_USER_ERROR );	
}
?>

O trecho de código acima deverá gerar o seguinte erro:

Fatal error: O número não pode ser maior que 100 in cursosphpaula_42index.php on line 7

Além da função acima, você também pode utilizar set_error_handler, porém, neste caso o PHP passa todo o gerenciamento de erros para suas mãos. Não creio que seja algo totalmente seguro (a não ser que estritamente necessário), pois, você vai ter que gerenciar todos os erros, e, caso necessário, matar (die ou exit) o script.

Utilizando exceções

Uma das maneiras que mais gosto para manipular erros são as exceções. Elas fazem parte da classe {php}Excpetion{/php}, onde você pode lançar erros com {php}throw{/php} e utilizar {php}try{/php} e {php}catch{/php}.

Funciona assim: Quando você quiser lançar um erro, simplesmente utilize o trecho de código abaixo:

throw new Exception("Mensagem de erro");

Para testar, você deve utilizar um bloco de {php}try{/php} e {php}catch{/php}. Dentro do bloco {php}try{/php}, você deve colocar o código que será executado normalmente (sem erros). {php}catch{/php} só será executado se o interpretador do PHP encontrar uma exceção. Veja:

<?php
// Uma função simples
function verifica( $max, $numero ) {
	// Se o máximo for menor que o número
	if ( $max < $numero ) {
		// Lança a exceção
		throw new Exception("Erro: número não pode ser maior que $max");
	} else {
		// Caso contrário mostra o número
		echo $numero;
	}
}

// Bloco try/catch
try {
	// Executa a função com o número maior que o máximo
	verifica( 100, 101 );
} catch (Exception $e) {
	// Se encontrar alguma exceção na função, para e mostra a mensagem
	echo $e->getMessage();
}
?>

É interessante lançar exceções em programação orientada a objetos, veja como fazer o mesmo em classes:

<?php 
class Numero
{
	// Propriedades
	public $numero;
	
	// Função para verificar número
	public function verifica ( $max, $numero ) {
		// Número atual
		$this->numero = $numero;
		
		// Verifica se o número é maior que o máximo
		if ( $numero > $max ) {
			throw new Exception("Erro: Número não pode ser maior que $max.");
		} else {
			echo $numero;
		}
	}
}

// Instância (objeto) de Numero
$numero = new Numero();

// Bloco try/catch
try {
	$numero->verifica( 100, 101 );
} catch (Exception $e) {
	echo $e->getMessage();
}
?>

Porém, lembre-se que todas as exceções lançadas com {php}throw{/php} devem ser capturadas com {php}catch{/php}, caso contrário, o PHP gera um erro fatal e para a execução do seu script.

Com as exceções, você tem os seguinte métodos prontos para serem utilizados:

  • getMessage () – A mensagem de erro
  • getCode () – O código de erro
  • getFile () – O arquivo de erro
  • getLine () – A linha do erro
  • getTrace () – Informações de contexto do erro
  • getTraceAsString () – Mesmo informação anterior, só que com string

Por exemplo:

<?php 
class Numero
{
	// Propriedades
	public $numero;
	
	// Função para verificar número
	public function verifica ( $max, $numero ) {
		// Número atual
		$this->numero = $numero;
		
		// Verifica se o número é maior que o máximo
		if ( $numero > $max ) {
			throw new Exception("Erro: Número não pode ser maior que $max.");
		} else {
			echo $numero;
		}
	}
}

// Instância (objeto) de Numero
$numero = new Numero();

// Bloco try/catch
try {
	$numero->verifica( 100, 101 );
} catch (Exception $e) {
	echo '<b>Erro: </b>';
	echo $e->getMessage();
	echo ' <b>Na linha: </b>';
	echo $e->getLine();
	echo ' <b>Arquivo: </b>';
	echo $e->getFile();
}
?>

Isso deverá gerar:

Erro: Número não pode ser maior que 100. Na linha: 15 Arquivo: E:ProgramasEasyPHPdatalocalwebcursosphpaula_42index.php

Muito interessante!

Concluindo

Claro que existem milhares de maneiras de manipular erros em PHP e cabe a você, ou sua equipe, escolher qual a melhor para seu projeto. Os exemplos do artigo acima dão apenas dicas sobre como é possível manipular erros em PHP, porém, você deve fazer modificações e adaptações para o seu código.

Não deixe de seguir todas as aulas do nosso curso gratuito de PHP e de PHP Orientado a Objetos.

Caso tenha dúvidas, não hesite em comentar.