0Pricing
PHP Academy · Lektion

Try, Catch und Finally

Behandeln Sie Laufzeit-Exceptions mit try/catch/finally-Blöcken auf robuste Weise.

Try, Catch und Finally ist eine kostenlose PHP Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des PHP Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der PHP Academy-Kurs umfasst insgesamt 4 Lektionen.

Ausnahmen und Fehler

PHP bietet zwei Möglichkeiten, Probleme zu signalisieren:

  • Fehler — herkömmliche PHP-Notices, Warnings und Fatals (im vorherigen Lesson besprochen)
  • Ausnahmen — Objekte, die ausgelöst werden, wenn etwas Außergewöhnliches passiert; sie werden mit try/catch abgefangen

Ausnahmen sind der moderne und bevorzugte Ansatz für die Behandlung behebbarer Fehler.

Eine Ausnahme auslösen

Verwenden Sie throw, um zu signalisieren, dass etwas schiefgelaufen ist:

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

echo divide(10, 2);   // 5
// divide(10, 0);     // throws exception

try-/catch-Block

Schließen Sie Code, der möglicherweise eine Ausnahme auslöst, in try ein und behandeln Sie Ausnahmen in catch:

<?php
try {
    $result = divide(10, 0);
    echo $result;
} catch (InvalidArgumentException $e) {
    echo 'Error: ' . $e->getMessage();
    echo ' in ' . $e->getFile() . ':' . $e->getLine();
}

Mehrere catch-Blöcke

Fangen Sie verschiedene Ausnahmetypen in separaten catch-Blöcken ab:

<?php
try {
    $pdo = new PDO($dsn, $user, $pass);
    $result = performQuery($pdo);
} catch (PDOException $e) {
    error_log('DB error: ' . $e->getMessage());
    echo 'Database unavailable';
} catch (RuntimeException $e) {
    echo 'Runtime error: ' . $e->getMessage();
} catch (\Throwable $e) {
    echo 'Unexpected error: ' . $e->getMessage();
}

finally-Block

finally wird unabhängig davon ausgeführt, ob eine Ausnahme ausgelöst wurde — ideal für Aufräumarbeiten:

<?php
$connection = null;
try {
    $connection = openDatabaseConnection();
    $data = fetchData($connection);
} catch (DatabaseException $e) {
    error_log($e->getMessage());
    echo 'DB error';
} finally {
    // Always runs — even if exception was thrown
    if ($connection) {
        closeConnection($connection);
    }
}

Ausnahmehierarchie

Die Hierarchie der Ausnahme-Klassen in PHP:

  • Throwable (Interface)
  • ├─ Error — Fehler der PHP-Engine (TypeError, ParseError …)
  • └─ Exception — Anwendungsausnahmen
  • ├─ RuntimeException
  • ├─ InvalidArgumentException
  • ├─ LogicException
  • └─ PDOException

Throwable abfangen

Fangen Sie sowohl Ausnahmen als auch PHP-Fehler mit Throwable ab:

<?php
try {
    $result = someFunction();
} catch (\Exception $e) {
    echo 'Exception: ' . $e->getMessage();
} catch (\Error $e) {
    echo 'PHP Error: ' . $e->getMessage();
}

// Or catch both at once:
try {
    // ...
} catch (\Throwable $e) {
    echo get_class($e) . ': ' . $e->getMessage();
}

Union-Catch (PHP 8)

PHP 8 ermöglicht es, mehrere Ausnahmetypen in einem catch-Block abzufangen:

<?php
try {
    processRequest();
} catch (InvalidArgumentException | RuntimeException $e) {
    echo 'Handled: ' . $e->getMessage();
}

// Compare PHP 7 approach:
// catch (InvalidArgumentException $e) { ... }
// catch (RuntimeException $e) { ... }

Ausnahmen erneut auslösen

Fangen Sie eine Ausnahme ab, protokollieren Sie sie und lösen Sie sie erneut aus, damit sie den Aufrufstapel hinaufgereicht wird:

<?php
function processOrder(int $id): void {
    try {
        $order = loadOrder($id);
        $order->process();
    } catch (PaymentException $e) {
        error_log('Payment failed for order ' . $id . ': ' . $e->getMessage());
        throw $e;  // re-throw after logging
    }
}

Ausnahmen verketten

Übergeben Sie die ursprüngliche Ausnahme als previous, um den Kontext zu erhalten:

<?php
try {
    $data = fetchFromAPI();
} catch (NetworkException $e) {
    throw new ServiceUnavailableException(
        'Cannot reach upstream service',
        0,
        $e  // $previous — preserves original cause
    );
}

// Retrieve original:
// $e->getPrevious()

set_exception_handler

Registrieren Sie einen globalen Handler für nicht abgefangene Ausnahmen:

<?php
set_exception_handler(function(\Throwable $e): void {
    error_log(sprintf(
        '[UNCAUGHT] %s: %s in %s:%d',
        get_class($e),
        $e->getMessage(),
        $e->getFile(),
        $e->getLine()
    ));
    http_response_code(500);
    echo 'An unexpected error occurred. Please try again.';
    exit(1);
});

Kurze Überprüfung

Welcher Block in try/catch/finally wird garantiert ausgeführt, unabhängig davon, ob eine Ausnahme ausgelöst wird?

Zusammenfassung: try/catch/finally

Zusammenfassung der Ausnahmebehandlung:

  • Ausnahmen mit throw new ExceptionClass() auslösen
  • Mit catch (Type $e) abfangen
  • Für verschiedene Typen mehrere catch-Blöcke verwenden
  • finally wird immer ausgeführt — für Aufräumarbeiten verwenden
  • Union-Catch in PHP 8: catch (A | B $e)
  • Erneut auslösen, um den Kontext des Aufrufstapels zu erhalten

Häufig gestellte Fragen

Ist die Lektion „Try, Catch und Finally“ kostenlos?

Ja — der vollständige Text von „Try, Catch und Finally“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des PHP Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der PHP Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Try, Catch und Finally“?

Behandeln Sie Laufzeit-Exceptions mit try/catch/finally-Blöcken auf robuste Weise. Du übst PHP Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um PHP Academy zu starten?

Keine Vorkenntnisse erforderlich. PHP Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.

Wie lange dauert die Lektion „Try, Catch und Finally“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser PHP Academy-Lektion Code schreiben und ausführen?

Ja. Jede PHP Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. PHP-Fehlertypen und Fehlerberichterstattung
  2. Try, Catch und Finally
  3. Benutzerdefinierte Exceptions erstellen
  4. Fehler protokollieren und Best Practices
← Zurück zu PHP Academy