try

(PHP 5, PHP 7, PHP 8)

Un bloque try delimita un segmento de código que puede lanzar con throw un error Throwable que necesita ser manejado. Un bloque try debe tener al menos un bloque catch o finally correspondiente.

Cuando se lanza un error Throwable en un bloque try, PHP intentará encontrar el primer bloque catch correspondiente para manejar el error. Si no se encuentra ninguno, la pila de llamadas se desenrolla hasta que se encuentra un bloque catch correspondiente o se alcanza el ámbito global. Un objeto no capturado se pasa entonces al manejador de excepciones definido con set_exception_handler(), si hay uno; de lo contrario, el script termina con un error fatal.

catch

(PHP 5, PHP 7, PHP 8)

Un bloque catch define cómo responder a un error Throwable lanzado. Especifica una o más subclases de Throwable (lo más habitual es Exception) que puede manejar, y opcionalmente una variable a la que se asigna la excepción.

El primer bloque catch que coincide con la clase del objeto Throwable lanzado manejará el error. La ejecución normal se reanuda después del bloque catch sin entrar en ningún otro bloque catch que también coincida.

Nota:

No se recomienda capturar objetos Error, ya que señalan un error de programación.

<?php
try {
    throw new Exception('Error');
} catch (Exception $e) {
    echo 'Excepción capturada: ', $e->getMessage(), "\n";
}

// Continuar la ejecución
echo "Hola mundo\n";

Excepción capturada: Error
Hola mundo

A partir de PHP 7.1.0, un bloque catch puede especificar una unión de subclases de Throwable que debe manejar, utilizando el carácter de barra vertical (|). Esto es útil cuando excepciones diferentes, de jerarquías de clases distintas, se manejan de la misma manera.

<?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();

string(11) "MyException"

Pueden utilizarse varios bloques catch para manejar de manera diferente distintas clases de errores Throwable.

<?php
try {
    do_something_io_related();
} catch (FileNotFoundException $e) {
    // Captura únicamente FileNotFoundException y actúa en ese caso
} catch (MissingPermissionException $e) {
    // Captura únicamente MissingPermissionException y actúa de forma diferente en ese caso
}

Los errores Throwable pueden lanzarse con throw (o relanzarse) dentro de un bloque catch.

<?php

class MyException extends Exception { }

class Test {
    public function testing() {
        try {
            try {
                throw new MyException('foo!');
            } catch (MyException $e) {
                // se relanza
                throw $e;
            }
        } catch (Exception $e) {
            var_dump($e->getMessage());
        }
    }
}

$foo = new Test;
$foo->testing();

string(4) "foo!"

<?php

class A extends Exception {}
class B extends Exception {}

try {
    throw new A;
} catch (A $e) {
    throw new B;
} catch (B) {
    echo 'Hola';
}

Fatal error: Uncaught B in /in/K8Tl9:9
Stack trace:
#0 {main}
  thrown in /in/K8Tl9 on line 9

A partir de PHP 8.0.0, el nombre de la variable de un Throwable capturado es opcional. Si no se especifica, el bloque catch se ejecutará igualmente pero no tendrá acceso al objeto lanzado.

<?php

class SpecificException extends Exception {}

function test() {
    throw new SpecificException('Oopsie');
}

try {
    test();
} catch (SpecificException) {
    print "Se lanzó una SpecificException, pero no nos importan los detalles.";
}

Se lanzó una SpecificException, pero no nos importan los detalles.

Consulte la sección sobre el manejo de errores para la jerarquía de Throwable y cómo definir excepciones personalizadas.