catch

Le mot-clé PHP catch

Lorsque le code à l'intérieur d'un bloc try rencontre une exception — un object qui signale qu'un problème est survenu — l'exécution s'arrête et PHP recherche un bloc catch correspondant pour la traiter. Le mot-clé catch désigne le type d'exception qu'il peut gérer et lie l'objet levé à une variable afin que vous puissiez l'inspecter. Sans catch, une exception non interceptée devient une erreur fatale et interrompt le script.

Cette page explique la syntaxe de catch, comment PHP choisit quel bloc s'exécute, comment lire les détails de l'exception interceptée, et les modèles courants (plusieurs catches, types union, re-lancement) que vous utiliserez dans du code réel.

Syntaxe

Un bloc catch suit toujours un bloc try. Il déclare un type d'exception et une variable qui reçoit l'objet levé :

<?php

try {
    // Code that may throw an exception
} catch (Exception $e) {
    // Runs only if a matching exception is thrown above
    echo $e->getMessage();
}

PHP fait correspondre un bloc catch lorsque l'objet levé est une instance du type déclaré. Comme toutes les exceptions intégrées étendent la classe de base Exception (et les deux étendent l'interface Throwable), catch (Exception $e) intercepte la plupart des exceptions. Intercepter Throwable capture également les objets Error tels que TypeError et DivisionByZeroError.

Vous pouvez associer catch à un bloc finally pour exécuter du code de nettoyage, qu'une exception se soit produite ou non.

Un exemple concret

La fonction ci-dessous lève une exception lorsqu'on lui demande de diviser par zéro. Le bloc catch intercepte cette exception et la rapporte au lieu de laisser le script planter :

<?php

function divide($numerator, $denominator)
{
    if ($denominator == 0) {
        throw new InvalidArgumentException("Division by zero.");
    }
    return $numerator / $denominator;
}

try {
    echo divide(10, 0);
} catch (InvalidArgumentException $e) {
    echo "Error: " . $e->getMessage();
}

// Output: Error: Division by zero.

Remarquez que le script continue de s'exécuter après le catch — le contrôle reprend à la ligne suivant la structure try/catch plutôt que d'être interrompu.

Lire les détails de l'exception interceptée

La variable dans une clause catch ($e ci-dessus) est l'objet exception lui-même. Elle expose des méthodes qui décrivent ce qui s'est passé :

<?php

try {
    throw new RuntimeException("Disk is full", 28);
} catch (RuntimeException $e) {
    echo $e->getMessage();  // Disk is full
    echo "\n";
    echo $e->getCode();     // 28
    echo "\n";
    echo $e->getLine();     // 4  (line where it was thrown)
}

Intercepter plusieurs types d'exceptions

Lorsqu'un bloc try peut échouer de différentes manières, listez plusieurs blocs catch. PHP les essaie de haut en bas et exécute le premier qui correspond, donc placez les types plus spécifiques avant les types généraux :

<?php

try {
    // Code that may throw different exceptions
    throw new InvalidArgumentException("bad input");
} catch (InvalidArgumentException $e) {
    echo "Invalid argument: " . $e->getMessage();
} catch (RuntimeException $e) {
    echo "Runtime problem: " . $e->getMessage();
} catch (Exception $e) {
    echo "Something else: " . $e->getMessage();
}

// Output: Invalid argument: bad input

Si catch (Exception $e) venait en premier, il intercepterait tout et les blocs plus spécifiques en dessous ne s'exécuteraient jamais.

Union catch (PHP 7.1+)

Lorsque deux types d'exceptions différents nécessitent un traitement identique, combinez-les avec un pipe | au lieu de dupliquer le bloc :

<?php

try {
    throw new RuntimeException("connection reset");
} catch (InvalidArgumentException | RuntimeException $e) {
    echo "Handled: " . $e->getMessage();
}

// Output: Handled: connection reset

Catch sans capture (PHP 8.0+)

Si vous n'avez pas besoin de l'objet exception, vous pouvez omettre entièrement la variable :

<?php

try {
    throw new Exception("ignored details");
} catch (Exception) {
    echo "An error occurred, retrying...";
}

// Output: An error occurred, retrying...

Re-lancement et chaînage d'exceptions

Parfois, un bloc catch doit consigner le problème puis le transmettre — ou encapsuler une exception de bas niveau dans une exception plus significative. Passez l'originale comme troisième argument du constructeur pour préserver la chaîne :

<?php

try {
    try {
        throw new RuntimeException("low-level failure");
    } catch (RuntimeException $e) {
        // Wrap and re-throw with context preserved
        throw new Exception("High-level operation failed", 0, $e);
    }
} catch (Exception $e) {
    echo $e->getMessage();              // High-level operation failed
    echo "\n";
    echo $e->getPrevious()->getMessage(); // low-level failure
}

Bonnes pratiques

• Interceptez le type le plus précis que vous pouvez gérer. Un catch (Throwable $e) générique peut masquer des bugs en avalant des erreurs de programmation que vous auriez dû corriger.
• Ordonnez du spécifique au général. Les sous-classes spécifiques doivent précéder leurs types parents.
• Ne laissez jamais un catch vide. Ignorer silencieusement une exception rend les échecs invisibles ; consignez-la au minimum.
• Levez des exceptions, ne retournez pas de drapeaux d'erreur. Combinez catch avec throw pour que les appelants ne puissent pas ignorer les échecs par inadvertance.
• Utilisez finally pour le nettoyage (fermeture de fichiers, libération de verrous) qui doit s'exécuter sur les chemins de succès et d'échec.

Sujets connexes

• PHP try — le bloc que catch protège
• PHP throw — lever une exception
• PHP finally — code de nettoyage garanti
• PHP exception — l'objet exception et ses méthodes

Pratique