Try, Catch, Finally

Fait partie de la section Programmation Orientée Objet du Journey PHP de Coddy — leçon 68 sur 91.

Maintenant que vous savez comment créer et lever des exceptions, vous devez apprendre comment les intercepter. La structure try-catch-finally vous permet de gérer les exceptions de manière appropriée au lieu de les laisser faire planter votre application.

Enveloppez le code qui pourrait lever une exception dans un bloc try, puis gérez l'exception dans un bloc catch :

<?php
class Calculator {
    public function divide(int $a, int $b): float {
        if ($b === 0) {
            throw new InvalidArgumentException("Cannot divide by zero");
        }
        return $a / $b;
    }
}

$calc = new Calculator();

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

Résultat :

Error: Cannot divide by zero

Vous pouvez intercepter différents types d'exceptions avec plusieurs blocs catch. PHP les vérifie dans l'ordre, placez donc les exceptions les plus spécifiques en premier :

<?php
try {
    // code risqué
} catch (InvalidArgumentException $e) {
    echo "Bad input: " . $e->getMessage();
} catch (Exception $e) {
    echo "Something went wrong: " . $e->getMessage();
}

Le bloc finally s'exécute indépendamment du fait qu'une exception ait été levée ou capturée. Il est parfait pour les tâches de nettoyage comme la fermeture de connexions :

<?php
try {
    echo "Attempting operation\n";
    throw new Exception("Failed");
} catch (Exception $e) {
    echo "Caught: " . $e->getMessage() . "\n";
} finally {
    echo "Cleanup complete";
}

Sortie :

Attempting operation
Caught: Failed
Cleanup complete

Le bloc finally s'exécute même si vous effectuez un retour depuis les blocs try ou catch, ce qui le rend fiable pour les opérations de nettoyage essentielles.

Défi

Facile

Construisons un système de traitement de fichiers qui démontre comment try-catch-finally fonctionne ensemble pour gérer les erreurs avec élégance tout en garantissant que le nettoyage a toujours lieu.

Vous organiserez votre code sur trois fichiers :

FileException.php — Créez une classe personnalisée FileException qui étend Exception. Cela représentera les erreurs liées aux fichiers dans votre système.
FileProcessor.php — Créez une classe FileProcessor qui simule des opérations sur les fichiers. Incluez le fichier FileException. Votre classe doit avoir :
- Une propriété booléenne privée $isOpen initialisée à false
- Une méthode open(string $filename): void qui définit $isOpen à true et affiche "Opening: [filename]". Si le nom du fichier est "invalid.txt", lancez une FileException avec le message "Cannot open file"
- Une méthode process(): void qui affiche "Processing file...". Si $isOpen est false, lancez une RuntimeException avec le message "File not open"
- Une méthode close(): void qui définit $isOpen à false et affiche "File closed"
- Une méthode isOpen(): bool qui retourne l'état actuel
main.php — Incluez le fichier FileProcessor. Vous recevrez une entrée : un nom de fichier.
Créez un FileProcessor et utilisez une structure try-catch-finally pour :
- Dans le bloc try : appelez open() avec le nom du fichier, puis appelez process()
- Attrapez FileException en premier et affichez "File error: [message]"
- Attrapez RuntimeException et affichez "Runtime error: [message]"
- Dans le bloc finally : vérifiez si le fichier est ouvert en utilisant isOpen(), et si c'est le cas, appelez close(). Ensuite, affichez "Cleanup complete"

Le bloc finally garantit que le nettoyage a lieu, que les opérations réussissent ou échouent. Ce modèle est essentiel pour gérer des ressources telles que des fichiers, des connexions à des bases de données ou des sockets réseau où le nettoyage doit se produire quel que soit ce qui se passe pendant le traitement.

Aide-mémoire

Utilisez try-catch-finally pour gérer les exceptions de manière élégante et vous assurer que le code de nettoyage s'exécute toujours :

<?php
try {
    // code qui pourrait lever une exception
} catch (ExceptionType $e) {
    // gérer l'exception
    echo $e->getMessage();
}

Interceptez plusieurs types d'exceptions avec des blocs catch séparés. Placez les exceptions les plus spécifiques en premier :

<?php
try {
    // code risqué
} catch (InvalidArgumentException $e) {
    echo "Bad input: " . $e->getMessage();
} catch (Exception $e) {
    echo "Something went wrong: " . $e->getMessage();
}

Le bloc finally s'exécute indépendamment du fait qu'une exception ait été levée ou interceptée, ce qui le rend idéal pour les opérations de nettoyage :

<?php
try {
    // tenter l'opération
} catch (Exception $e) {
    // gérer l'erreur
} finally {
    // le code de nettoyage s'exécute toujours
}

Essayez vous-même

<?php
require_once 'FileProcessor.php';

// Lire l'entrée
$filename = trim(fgets(STDIN));

// TODO: Créer une instance de FileProcessor

// TODO: Utiliser une structure try-catch-finally :
// - Dans le bloc try : appeler open() avec le nom du fichier, puis appeler process()
// - Attraper FileException en premier et afficher "File error: [message]"
// - Attraper RuntimeException et afficher "Runtime error: [message]"
// - Dans le bloc finally : vérifier si le fichier est ouvert avec isOpen(), si oui appeler close()
//   Ensuite, afficher "Cleanup complete"

?>