O PHP possui um modelo de exceções similar ao de outras linguagens
de programação. Uma exceção pode ser lançada (throw
) e capturada (catch
).
Código pode ser envolvido por um bloco try
para facilitar a captura
de exceções potenciais. Cada bloco try
precisa ter ao menos um bloco
catch
ou finally
correspondente.
O objeto lançado precisa ser uma instância da classe Exception ou uma subclasse de Exception. Tentar lançar um objeto sem essa ascendência resultará em um erro fatal.
catch
Múltiplos blocos catch
podem ser utilizados para capturar exceções
diferentes. A execução normal (quando nenhuma exceção é lançada dentro de um
try
) irão continuar a execução após o último catch
definido em sequência.
Exceções podem ser lançadas (ou relançadas) dentro um bloco catch
.
Quando uma exceção é lançada o código seguinte não é executado,
e o PHP tentará encontrar o primeiro bloco catch
coincidente.
Se uma exceção não for capturada, um erro PHP fatal será lançado com a mensagem
"Uncaught Exception ...
" na ausência de uma função
definida com set_exception_handler().
A partir do PHP 7.1 um bloco catch
pode especificar múltiplas exceções
usando o caractere pipe (|
). Isto é útil quando
diferentes exceções de diferentes hierarquias de classes são tratadas
da mesma forma.
finally
A partir do PHP 5.5, um bloco finally
pode ser especificado após
ou no lugar de blocos catch
. Códigos dentro de finally
sempre serão
executados depois do try
ou catch
, independente se houve o
lançamento de uma exceção, e antes que a execução normal continue.
Nota:
Funções internas ao PHP utilizam principalmente aviso de erros. Apenas extensões orientadas a objetos utilizam exceções. No entanto os erros podem ser transformados em exceções com ErrorException.
A biblioteca padrão do PHP (SPL) fornece várias exceções nativas.
Exemplo #3 Lançando uma exceção
<?php
function inverse($x) {
if (!$x) {
throw new Exception('Divisão por zero.');
}
return 1/$x;
}
try {
echo inverse(5) . "\n";
echo inverse(0) . "\n";
} catch (Exception $e) {
echo 'Exceção capturada: ', $e->getMessage(), "\n";
}
// Execução continua
echo "Olá mundo\n";
?>
O exemplo acima irá imprimir:
0.2 Exceção capturada: Divisão por zero. Olá mundo
Exemplo #4 Manipulação de exceções com bloco finally
<?php
function inverse($x) {
if (!$x) {
throw new Exception('Divisão por zero.');
}
return 1/$x;
}
try {
echo inverse(5) . "\n";
} catch (Exception $e) {
echo 'Exceção capturada: ', $e->getMessage(), "\n";
} finally {
echo "Primeiro finaly.\n";
}
try {
echo inverse(0) . "\n";
} catch (Exception $e) {
echo 'Exceção capturada: ', $e->getMessage(), "\n";
} finally {
echo "Segundo finally.\n";
}
// Execução continua
echo "Olá mundo\n";
?>
O exemplo acima irá imprimir:
0.2 Primeiro finally. Exceção capturada: Divisão por zero. Segundo finally. Olá mundo
Exemplo #5 Exceções empilhadas
<?php
class MyException extends Exception { }
class Test {
public function testing() {
try {
try {
throw new MyException('foo!');
} catch (MyException $e) {
// rethrow it
throw $e;
}
} catch (Exception $e) {
var_dump($e->getMessage());
}
}
}
$foo = new Test;
$foo->testing();
?>
O exemplo acima irá imprimir:
string(4) "foo!"
Exemplo #6 Manipulação de múltiplas exceções no mesmo bloco catch
<?php
class MyException extends Exception { }
class MyOtherException extends Exception { }
class Test {
public function testing() {
try {
throw new MyException();
} catch (MyException | MyOtherException $e) {
var_dump(get_class($e));
}
}
}
$foo = new Test;
$foo->testing();
?>
O exemplo acima irá imprimir:
string(11) "MyException"