PHP-Fehler

Fehler zu begegnen ist ein normaler Bestandteil des PHP-Schreibens. Je schneller Sie einen Fehler lesen und verstehen, auf welcher Ebene er auftritt, warum PHP ihn ausgelöst hat und wie Sie damit umgehen sollen, desto schneller liefern Sie funktionierenden Code. Diese Seite erklärt PHPs Fehlerstufen (die E_*-Konstanten), den Unterschied zwischen Fehlern und Exceptions in modernem PHP sowie einen praktischen Workflow für Meldung, Protokollierung und Behandlung.

PHP-Fehlerstufen

Wenn PHP ein Problem erkennt, löst es dieses auf einer bestimmten Stufe aus, die durch eine E_*-Konstante identifiziert wird. Die Stufe zeigt an, wie schwerwiegend das Problem ist und ob das Skript weiterläuft. Sie kombinieren diese Konstanten mit error_reporting() und der php.ini-Direktive error_reporting, um zu bestimmen, welche Stufen angezeigt oder protokolliert werden.

Dies sind Bitmaskenkonstanten, daher kombinieren Sie sie mit dem bitweisen ODER-Operator (|) und schließen Stufen mit & plus ~ aus:

<?php
// Report everything except notices and deprecations
error_reporting(E_ALL & ~E_NOTICE & ~E_DEPRECATED);

Wichtig: Seit PHP 8.0 wurden viele frühere Warnungen und Hinweise zu geworfenen Error-Exceptions hochgestuft (z. B. erzeugt das Lesen eines undefinierten Array-Schlüssels nun eine Warnung, während der Aufruf einer undefinierten Methode einen Error wirft). Ob ein Problem ein ausgelöster Fehler oder eine geworfene Exception ist, entscheidet darüber, wie Sie ihn abfangen — siehe unten.

Fehler vs. Exceptions

PHP hat zwei verwandte, aber getrennte Mechanismen:

• Traditionelle Fehler werden von der Engine ausgelöst und über error_reporting, display_errors und einen optionalen Handler weitergeleitet, der mit set_error_handler() gesetzt wird. Sie sind keine Objekte, die Sie mit catch abfangen können (es sei denn, Ihr Handler konvertiert sie).
• Exceptions sind Objekte, die Sie mit throw werfen und mit try/catch-Blöcken abfangen. Seit PHP 7 werden fatale Engine-Probleme auch als Error-Objekte geworfen (wie TypeError oder DivisionByZeroError), und sowohl Exception als auch Error implementieren das Throwable-Interface — daher fängt catch (\Throwable $e) alles Fangbare ab.

<?php
try {
    // intdiv() throws a DivisionByZeroError on division by zero
    echo intdiv(10, 0);
} catch (\Throwable $e) {
    echo get_class($e) . ": " . $e->getMessage();
}
// Output: DivisionByZeroError: Division by zero

Häufige Ursachen von PHP-Fehlern

Die meisten Fehler lassen sich auf eine kleine Anzahl von Ursachen zurückführen:

• Syntaxfehler — ein fehlendes Semikolon oder eine nicht übereinstimmende Klammer (E_PARSE).
• Undefinierte Symbole — Verwendung einer Variable, Konstante, Funktion oder eines Array-Schlüssels, der nicht existiert.
• Typkonflikte — Übergabe des falschen Typs an einen typisierten Parameter (wirft TypeError).
• Veraltete Funktionen — Funktionen oder Syntax, die zur Entfernung vorgesehen sind (E_DEPRECATED).
• Ressourcenlimits — Erschöpfung von memory_limit oder Überschreitung von max_execution_time.
• Externe Fehler — eine fehlende Datei oder eine Datenbank-/API-Verbindung, die abgelehnt wird oder das Zeitlimit überschreitet.
• Nicht abgefangene Exceptions — ein throw ohne passendes catch, was zu einem fatalen Fehler wird.

<?php
// Reading an undefined variable raises an E_WARNING and yields null
echo $undefined_variable ?? "fallback";
// Output: fallback

Der Null-Koaleszenz-Operator (??) oben ist die idiomatische Methode, einen Wert zu lesen, der möglicherweise undefiniert ist, ohne eine Warnung auszulösen.

Fehlerberichterstattung konfigurieren

Steuern Sie, welche Stufen angezeigt werden und wohin sie gehen. In der Entwicklung alles anzeigen; in der Produktion Fehler vor Benutzern verbergen, aber protokollieren.

<?php
// Development: show all errors on screen
error_reporting(E_ALL);
ini_set('display_errors', '1');

// Production: hide from users, write to the error log instead
// error_reporting(E_ALL);
// ini_set('display_errors', '0');
// ini_set('log_errors', '1');

Die entsprechenden php.ini-Einstellungen sind error_reporting, display_errors, log_errors und error_log. Für programmatische Steuerung siehe error_reporting() und um den letzten Fehler zu inspizieren verwenden Sie error_get_last().

Fehler im Code behandeln

Es gibt drei ergänzende Werkzeuge:

1. Exceptions abfangen mit try/catch, damit ein behebbarer Fehler das Skript nicht zum Absturz bringt:

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

try {
    echo safeDivide(10, 0);
} catch (InvalidArgumentException $e) {
    echo "Handled: " . $e->getMessage();
}
// Output: Handled: Cannot divide by zero

2. Einen benutzerdefinierten Fehler-Handler installieren mit set_error_handler(), um traditionelle Fehler in Exceptions umzuwandeln oder sie in Ihrem eigenen Format zu protokollieren:

<?php
set_error_handler(function (int $level, string $message, string $file, int $line) {
    // Turn a traditional warning/notice into an ErrorException so it can be caught
    throw new ErrorException($message, 0, $level, $file, $line);
});

try {
    // Reading a missing file raises an E_WARNING, now converted to an exception
    $contents = file_get_contents('/no/such/file.txt');
} catch (\Throwable $e) {
    echo "Caught: " . $e->getMessage();
}
// Output: Caught: file_get_contents(/no/such/file.txt): Failed to open stream: No such file or directory

3. Eigene Fehler auslösen mit trigger_error(), um anwendungsseitige Probleme durch dieselbe Pipeline wie Engine-Fehler zu signalisieren.

Best Practices

• Setzen Sie display_errors in der Produktion auf 0 — durchgesickerte Stack-Traces sind ein Sicherheitsrisiko. Verwenden Sie stattdessen log_errors und ein konfiguriertes error_log.
• Entwickeln Sie mit error_reporting(E_ALL), damit Hinweise und veraltete Funktionen frühzeitig sichtbar werden.
• Bevorzugen Sie catch (\Throwable $e) auf oberster Ebene, um sowohl Exception als auch Error abzufangen.
• Unterdrücken Sie Probleme nie mit dem @-Operator; beheben Sie die Ursache oder behandeln Sie sie explizit.
• Zentralisieren Sie die Protokollierung mit error_log(), damit jeder Fehler an einem Ort landet.

Fazit

Das Lesen eines PHP-Fehlers beginnt mit seiner Stufe und damit, ob es sich um einen ausgelösten Fehler oder eine geworfene Exception handelt. Mit error_reporting() je nach Umgebung abgestimmt, einem benutzerdefinierten Handler, der Fehler in das Exception-System leitet, und try/catch um Code, der fehlschlagen kann, können Sie Probleme schnell diagnostizieren und die Produktion stabil halten. Lesen Sie weiter mit PHP Exceptions und error_reporting() für tiefere Einblicke.

Übungen