💥

Les Exceptions

Les erreurs arrivent. Un fichier manquant, une division par zéro, un réseau coupé... Les exceptions permettent de gérer ces erreurs proprement sans crasher ton programme !

Démo interactive

Le chemin d'un try / catch / finally

Active ou non l'erreur, puis lance l'exécution. Si une exception est levée, le flux bifurque vers catch (rouge). Sinon il continue (vert). Le bloc finally s'exécute toujours.

Une erreur est lancée ?

Choisis un scénario puis clique sur Exécuter.

🎪 Analogie : Le Filet de Sécurité

❌ Sans exception

L'acrobate fait un saut périlleux. S'il rate... BOUM 💀 Le spectacle s'arrête, tout le cirque ferme.

🎪 → 😰 → 💥 → ☠️

✅ Avec try/catch

L'acrobate fait un saut périlleux avec un filet en dessous. S'il rate, il rebondit et le spectacle continue !

🎪 → 😰 → 🥅 → 😅 → 🎉

try = tenter le saut périlleux
catch = le filet qui rattrape
finally = ranger le filet (toujours fait, succès ou échec)

🎮 Démo Interactive : Flux d'une Exception

Clique sur un scénario pour voir comment le code s'exécute :

try {

resultat = 10 / diviseur;
console.log("Résultat: " + resultat);

}

↓

catch (erreur) {

console.log("Erreur: " + erreur.message);

}

↓

finally {

console.log("Opération terminée");

}

📺 Console

// Clique sur un scénario pour voir le résultat

📝 Syntaxe Try/Catch

try {
    // Code risqué
    int result = 10 / divisor;
    System.out.println("Résultat: " + result);

} catch (ArithmeticException e) {
    // Gestion de l'erreur spécifique
    System.out.println("Erreur: " + e.getMessage());

} catch (Exception e) {
    // Gestion générique (toutes les autres erreurs)
    System.out.println("Erreur inattendue: " + e);

} finally {
    // Toujours exécuté (nettoyage)
    System.out.println("Fin de l'opération");
}

☕ Java : Les exceptions sont des objets. On peut throw une exception avec throw new Exception("message"). Distinction entre checked (obligatoire à gérer) et unchecked (RuntimeException).

try:
    # Code risqué
    result = 10 / divisor
    print(f"Résultat: {result}")

except ZeroDivisionError as e:
    # Gestion de l'erreur spécifique
    print(f"Erreur: {e}")

except Exception as e:
    # Gestion générique
    print(f"Erreur inattendue: {e}")

else:
    # Exécuté si aucune exception
    print("Succès !")

finally:
    # Toujours exécuté
    print("Fin de l'opération")

🐍 Python : Utilise except au lieu de catch. Bonus : le bloc else s'exécute uniquement si aucune exception n'a été levée !

try {
    // Code risqué
    if (divisor === 0) {
        throw new Error("Division par zéro !");
    }
    const result = 10 / divisor;
    console.log(`Résultat: ${result}`);

} catch (error) {
    // Gestion de l'erreur
    console.error("Erreur:", error.message);

} finally {
    // Toujours exécuté
    console.log("Fin de l'opération");
}

🟨 JavaScript : Un seul bloc catch attrape toutes les erreurs. JS ne fait pas de distinction de types automatique (pas de division par zéro native). Utilise instanceof pour vérifier le type d'erreur.

// Go n'a PAS de try/catch !
// On retourne les erreurs explicitement

func divide(a, b int) (int, error) {
    if b == 0 {
        return 0, errors.New("division par zéro")
    }
    return a / b, nil
}

// Utilisation
result, err := divide(10, divisor)
if err != nil {
    fmt.Println("Erreur:", err)
} else {
    fmt.Println("Résultat:", result)
}

// Pour le "finally", on utilise defer
defer fmt.Println("Fin de l'opération")

🐹 Go : Philosophie différente ! Les erreurs sont des valeurs retournées, pas des exceptions. defer remplace finally. Pour les erreurs fatales : panic() et recover().

📋 Types d'Exceptions Courants

⚡

Runtime

• NullPointerException
• IndexOutOfBounds
• ArithmeticException
• ClassCastException

Erreurs de logique dans le code

📁

I/O (Entrées/Sorties)

• FileNotFoundException
• IOException
• PermissionDenied
• NetworkError

Problèmes fichiers/réseau

🎨

Custom (Perso)

• UserNotFoundException
• InvalidPasswordError
• InsufficientFundsError
• RateLimitExceeded

Créées par le développeur

🎯 Effet Domino : Propagation d'Exception

Sans gestion, une exception remonte la pile d'appels jusqu'à crasher le programme. Avec un catch, on arrête la propagation !

main

func1

func2

💥

func3

func4

// Clique pour voir la propagation

✨ Bonnes Pratiques

✅ À faire

✓ Attraper les exceptions spécifiques d'abord
✓ Logger les erreurs pour debug
✓ Utiliser finally pour fermer les ressources
✓ Créer des exceptions custom métier
✓ Documenter les exceptions possibles

❌ À éviter

✗ catch (Exception e) {} → catch vide !
✗ Utiliser exceptions pour le flow normal
✗ Attraper et ignorer silencieusement
✗ catch(Exception) trop général en premier
✗ Throw sans message explicatif

💡 Règle d'or

"Fail fast, recover gracefully"
Détecte les erreurs tôt, mais donne une chance au programme de se rétablir. Une exception bien gérée vaut mieux qu'un crash silencieux !

🧠

Mode Survie : Exceptions

Une erreur = Game Over ! 10 questions aléatoires.