Manipulando erros em PHP – Aula 42

Nenhum produto encontrado nessa seleção.

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:

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.