Fehlersuche und Debugging in PHP

Erste Schritte: Fehlersuche und Debugging in PHP

Auch erfahrene Entwickler stoßen in PHP‑Projekten auf Warnungen, „Undefined Index“-Meldungen oder weiße Seiten (Fatal Errors). Ein strukturiertes Debugging hilft dir, Probleme zu identifizieren und schnell zu lösen. Dieses Tutorial zeigt gängige Techniken – von error_reporting über var_dump bis zu Xdebug.

1. error_reporting & display_errors

PHPs Fehlerausgabe wird über php.ini‑Direktiven gesteuert. In der Entwicklungsumgebung willst du möglichst alle Fehlertypen sehen:

; php.ini (Dev)
error_reporting = E_ALL
display_errors  = On
  • E_ALL zeigt Notices, Deprecations, Warnings und Fatals.
  • display_errors sollte nur in Dev auf On stehen.
    In Produktion loggst du Fehler, aber zeigst sie nicht (Sicherheitsrisiko).

Auf Shared‑Hosting ohne ini‑Zugriff kannst du am Skript‑Anfang notfalls:

ini_set('display_errors', 1);
error_reporting(E_ALL);

2. Fehlertypen verstehen

  • Notice: Geringfügig, z. B. „Undefined index“ – deutet auf Logik‑Probleme hin.
  • Warning: Schwere Stufe, Skript läuft weiter, z. B. fehlende Datei in include.
  • Fatal Error: Skript bricht ab (Class not found, Syntaxfehler …)
  • Parse Error: Syntax‑Fehler vor Ausführung – falsche Klammern, Semikolon vergessen.

3. Schnelles Debugging mit var_dump

Wenn etwas nicht den erwarteten Wert hat, greif zu

var_dump($variable);
print_r($array, true); // zweite Param. true => String zurück

Du kannst das in Kombination mit <pre> sauber formatieren:

echo '<pre>';
var_dump($userData);
echo '</pre>';

4. Fehler– und Exception‑Handler

Du kannst eigene Callback‑Funktionen registrieren, damit auch ungefangene Fehler in einem zentralen Log landen:

function myErrorHandler($errno, $errstr, $file, $line) {
    error_log("[$errno] $errstr in $file:$line");
}
set_error_handler('myErrorHandler');

function myExceptionHandler($e) {
    error_log("Uncaught: " . $e->getMessage());
}
set_exception_handler('myExceptionHandler');
  • Damit schreibst du alle Fehler ins System‑Log oder in eine eigene Datei.
  • In Frameworks (Laravel, Symfony, phpFK …) gibt es bereits Handler.

5. echo‑Debugging vs. Logging

echo/var_dump ist schnell, aber unsauber in Live‑Systemen.
Nutze error_log() oder eine Library (Monolog) :

error_log('Debug‑Info: ' . json_encode($data));

So bleibt die Ausgabe aus dem HTML getrennt.

6. Xdebug – Step‑Debugger

  • Xdebug ist eine PHP‑Erweiterung, mit der du Breakpoints, Stack‑Traces und Profiling erhältst.
  • Installiere sie (Linux pecl install xdebug, bei XAMPP häufig vorinstalliert), aktiviere in php.ini :
zend_extension=xdebug
xdebug.mode=debug
xdebug.start_with_request=yes
xdebug.client_host=127.0.0.1
xdebug.client_port=9003

Dann kannst du in VS Code, PhpStorm oder NetBeans Breakpoints setzen und Variable‑Werte live inspizieren.

7. Composer‑Autoload‑Fehler

Wenn eine Klasse „not found“ ist, oft vergessen,
composer dump‑autoload auszuführen oder die namespace‑Deklaration falsch geschrieben.

8. Debug‑Tipps für Datenbank‑Issues

  • SQL Ausgabe: Gib das Prepared‑Statement + Parameter aus, wenn keine Zeilen zurückkommen.
  • PDO::ERRMODE_EXCEPTION aktivieren:
$pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);

So wirft PDO Exceptions statt stiller Fehlercodes.

9. Browser + Network‑Tab

Für Ajax/Fetch‑Aufrufe: im DevTools Network‑Tab schauen,
ob das PHP‑Script 500‑Fehler liefert oder unerwartete Ausgaben.

10. Zusammenfassung

  • Stelle E_ALL + display_errors=On in Dev ein.
  • Nutzung von var_dump, print_r und error_log für schnelle Hinweise.
  • Eigenen Fehler‑/Exception‑Handler definieren oder Framework‑Logger verwenden.
  • Für komplexe Bugs: Step‑Debugging mit Xdebug + IDE.
  • In Produktion nur loggen, niemals Fehler direkt anzeigen.

Fazit

Ein systematisches Vorgehen bei der Fehlersuche spart Zeit – und Nerven.
Nutze PHPs eingebaute Fehlerausgabe in der Entwicklungsumgebung,
ergänze sie durch Logging oder Xdebug‑Breakpoints, und halte deine Produktionsserver sauber, indem du Fehler nur protokollierst.
So behältst du die Kontrolle, selbst wenn unerwartete Probleme auftreten.