try

(PHP 5, PHP 7, PHP 8)

Un bloc try délimite un segment de code susceptible de lancer avec throw une erreur Throwable qui doit être traitée. Un bloc try doit avoir au moins un bloc catch ou finally correspondant.

Lorsqu'une erreur Throwable est lancée dans un bloc try, PHP tente de trouver le premier bloc catch correspondant pour traiter l'erreur. S'il n'en trouve aucun, la pile d'appels est dépilée jusqu'à ce qu'un bloc catch correspondant soit trouvé ou que la portée globale soit atteinte. Un objet non attrapé est alors transmis au gestionnaire d'exceptions défini avec set_exception_handler(), s'il y en a un ; sinon, le script se termine avec une erreur fatale.

catch

(PHP 5, PHP 7, PHP 8)

Un bloc catch définit comment réagir à une erreur Throwable lancée. Il spécifie une ou plusieurs sous-classes de Throwable (le plus souvent Exception) qu'il peut traiter, et éventuellement une variable à laquelle l'exception est assignée.

Le premier bloc catch qui correspond à la classe de l'objet Throwable lancé traite l'erreur. L'exécution normale reprend après le bloc catch, sans entrer dans les autres blocs catch correspondants.

Note:

Il n'est pas recommandé d'attraper les objets Error, car ils signalent une erreur de programmation.

<?php
try {
    throw new Exception('Erreur');
} catch (Exception $e) {
    echo 'Exception attrapée : ', $e->getMessage(), "\n";
}

// Poursuite de l'exécution
echo "Bonjour le monde\n";

Exception attrapée : Erreur
Bonjour le monde

À partir de PHP 7.1.0, un bloc catch peut spécifier une union de sous-classes de Throwable qu'il doit traiter, en utilisant le caractère pipe (|). Ceci est utile lorsque différentes exceptions, issues de hiérarchies de classes différentes, sont traitées de la même manière.

<?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"

Plusieurs blocs catch peuvent être utilisés pour traiter différemment différentes classes d'erreurs Throwable.

<?php
try {
    do_something_io_related();
} catch (FileNotFoundException $e) {
    // Attrape uniquement FileNotFoundException et agit dans ce cas
} catch (MissingPermissionException $e) {
    // Attrape uniquement MissingPermissionException et agit différemment dans ce cas
}

Des erreurs Throwable peuvent être lancées (ou relancées) avec throw dans un bloc catch.

<?php

class MyException extends Exception { }

class Test {
    public function testing() {
        try {
            try {
                throw new MyException('foo!');
            } catch (MyException $e) {
                // la relance
                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 'Bonjour';
}

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

À partir de PHP 8.0.0, le nom de la variable d'une erreur Throwable attrapée est optionnel. S'il n'est pas spécifié, le bloc catch s'exécute quand même, mais n'a pas accès à l'objet lancé.

<?php

class SpecificException extends Exception {}

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

try {
    test();
} catch (SpecificException) {
    print "Une SpecificException a été lancée, mais les détails importent peu.";
}

Une SpecificException a été lancée, mais les détails importent peu.

Voir la section sur la gestion des erreurs pour la hiérarchie de Throwable et la manière de définir des exceptions personnalisées.