Beim Debugging von PHP-Code reicht es oft nicht, nur den Wert einer Variablen zu sehen. Man braucht auch den Datentyp und bei Strings die Länge. Die Funktion var_dump() liefert genau diese Informationen und zeigt bei Arrays und Objekten zusätzlich die vollständige Struktur an. Damit ist sie das wichtigste Werkzeug, um Typ-Probleme aufzuspüren, die mit print_r() unsichtbar bleiben.
Wichtig: var_dump() zeigt interne Datenstrukturen inklusive Datenbankfelder, Session-Inhalte und Dateipfade. Auf einer Live-Webseite darf diese Ausgabe nie sichtbar sein. Stattdessen Output-Buffering in Kombination mit error_log() verwenden.
Syntax
Die Funktion akzeptiert einen oder mehrere Werte und gibt die Informationen direkt aus. Sie hat keinen Rückgabewert.
var_dump(mixed $value, mixed ...$values): void
Anders als print_r() besitzt var_dump() keinen Return-Modus. Die Ausgabe geht immer direkt an den Browser oder die Konsole. Um sie abzufangen, braucht man Output-Buffering.
Einfache Datentypen
Bei Strings zeigt var_dump() den Typ, die Länge und den Wert an. Bei Integer und Float den Typ und den Wert. Mehrere Variablen können in einem Aufruf untersucht werden.
<?php
$name = "Max";
$alter = 30;
$aktiv = true;
var_dump($name, $alter, $aktiv);
/* Ausgabe:
string(3) "Max"
int(30)
bool(true) */
?>
Die Zahl in Klammern bei Strings gibt die Länge in Bytes an. Bei UTF-8-Strings mit Umlauten kann diese Zahl größer sein als die Anzahl der sichtbaren Zeichen, weil Umlaute zwei Bytes belegen.
Praxis-Szenario: Typ-Verwirrung debuggen
Einer der häufigsten Gründe für schwer auffindbare Fehler in PHP sind Typ-Verwechslungen. Wer Daten über ein Formular oder die URL empfängt, erhält immer Strings. Das führt zu überraschenden Ergebnissen bei strikten Vergleichen.
<?php
$id = $_GET['id']; // z.B. "123"
/* Sieht richtig aus, ist aber false */
if ($id === 123) {
echo "Gefunden";
}
/* var_dump zeigt das Problem sofort */
var_dump($id);
/* Ausgabe: string(3) "123"
$id ist ein String, keine Zahl! */
/* Loesung: Type-Cast oder intval() */
$id = (int) $id;
var_dump($id);
/* Ausgabe: int(123) */
?>
Ohne var_dump() wäre dieses Problem mit print_r() oder echo nicht erkennbar, weil beide einfach 123 ausgeben, ohne den Typ zu verraten.
Arrays untersuchen
Bei Arrays zeigt die Funktion die Anzahl der Elemente, jeden Schlüssel und zu jedem Wert den Datentyp. Verschachtelte Arrays werden vollständig aufgelöst.
<?php
$daten = [
'name' => 'Alice',
'rollen' => ['admin', 'editor'],
'aktiv' => true,
];
var_dump($daten);
/* Ausgabe:
array(3) {
["name"]=> string(5) "Alice"
["rollen"]=> array(2) {
[0]=> string(5) "admin"
[1]=> string(6) "editor"
}
["aktiv"]=> bool(true)
} */
?>
Objekte untersuchen
var_dump() zeigt bei Objekten den Klassennamen, die interne Objekt-ID und alle Eigenschaften mit Typ und Wert, auch private und geschützte. Das ist ein wichtiger Unterschied zu print_r(), das nur öffentliche Eigenschaften anzeigt.
<?php
class Produkt {
public string $name;
public float $preis;
private int $lager = 50;
public function __construct(
string $name, float $preis
) {
$this->name = $name;
$this->preis = $preis;
}
}
$p = new Produkt('Tastatur', 49.99);
var_dump($p);
/* Ausgabe:
object(Produkt)#1 (3) {
["name"]=> string(8) "Tastatur"
["preis"]=> float(49.99)
["lager":"Produkt":private]=>
int(50)
} */
?>
__debugInfo() für kontrollierte Ausgabe
Seit PHP 5.6 können Klassen mit der Magic Method __debugInfo() steuern, welche Informationen var_dump() anzeigt. Das ist nützlich, um sensible Daten wie Passwörter oder API-Schlüssel aus der Debug-Ausgabe auszuschließen.
<?php
class DbConnection {
private string $host;
private string $passwort;
private int $queries = 0;
public function __construct(
string $host, string $passwort
) {
$this->host = $host;
$this->passwort = $passwort;
}
public function __debugInfo(): array
{
return [
'host' => $this->host,
'passwort' => '***verborgen***',
'queries' => $this->queries,
];
}
}
$db = new DbConnection('localhost', 'geheim');
var_dump($db);
/* Das echte Passwort wird nicht angezeigt */
?>
null, false und leere Strings unterscheiden
Ein wichtiger Vorteil gegenüber print_r(): var_dump() kann Werte unterscheiden, die print_r() identisch darstellt.
<?php
var_dump(null); // NULL
var_dump(false); // bool(false)
var_dump(''); // string(0) ""
var_dump(0); // int(0)
var_dump('0'); // string(1) "0"
?>
Bei print_r() würden null, false und der leere String alle als leere Ausgabe erscheinen. var_dump() macht den Unterschied sofort sichtbar. Das ist besonders wichtig, weil 0 == false == null == '' bei losen Vergleichen in PHP alle als gleich gelten.
Ausgabe im Browser lesbar machen
Im Browser gehen Zeilenumbrüche und Einrückungen verloren, weil HTML Whitespace zusammenfasst. Ein <pre>-Tag sorgt für lesbare Formatierung.
<?php
echo '<pre>';
var_dump($daten);
echo '</pre>';
?>
Im CLI (Kommandozeile) ist die Formatierung dagegen von Haus aus korrekt, weil Zeilenumbrüche dort direkt dargestellt werden. Wer sowohl Browser als auch CLI bedienen will, kann mit php_sapi_name() den Kontext erkennen und das <pre>-Tag nur im Browser ausgeben.
Xdebug verändert var_dump()
Xdebug ist eine weit verbreitete PHP-Extension für Debugging. Sie überschreibt das Standard-Verhalten von var_dump() und liefert stattdessen eine farbige, HTML-formatierte Ausgabe. Das führt häufig zu Verwirrung: Auf dem Entwicklungsrechner sieht var_dump() anders aus als auf dem Produktiv-Server.
Außerdem begrenzt Xdebug die Ausgabetiefe standardmäßig auf 3 Ebenen. Bei tief verschachtelten Strukturen erscheint dann nur ein Auslassungszeichen. Die Limits lassen sich in der php.ini anpassen:
; Maximale Verschachtelungstiefe
xdebug.var_display_max_depth = 5
; Maximale Anzahl Array-Elemente
xdebug.var_display_max_children = 256
; Maximale String-Laenge in Bytes
xdebug.var_display_max_data = 1024
Wenn in der Ausgabe Daten zu fehlen scheinen, liegt es meistens an diesen Xdebug-Limits. Ohne Xdebug zeigt var_dump() immer die vollständige Struktur an.
Ausgabe in Variable speichern
Anders als print_r() hat var_dump() keinen Return-Modus. Um die Ausgabe in einer Variable zu speichern oder in eine Log-Datei zu schreiben, hilft Output-Buffering.
<?php
ob_start();
var_dump($daten);
$debug = ob_get_clean();
/* Sicher in die Log-Datei schreiben */
error_log('Debug: ' . $debug);
?>
Mit ob_start() wird die Ausgabe abgefangen, statt sie an den Browser zu senden. ob_get_clean() liefert den Inhalt des Puffers als String und leert ihn gleichzeitig. Dieses Pattern eignet sich gut für Produktions-Debugging, weil die Ausgabe nur in der Log-Datei landet.
Vergleich: var_dump(), print_r() und var_export()
PHP bietet drei Funktionen zur Variablen-Inspektion. Jede hat ihren eigenen Schwerpunkt.
var_dump() zeigt Typ, Länge und Wert. Sie ist die beste Wahl für Debugging, besonders wenn der Datentyp entscheidend ist.
print_r() liefert eine kompakte, lesbare Darstellung ohne Typ-Info. Ideal für einen schnellen Überblick und für Logging mit error_log().
var_export() gibt gültigen PHP-Code zurück, der den Wert erzeugt. Damit lassen sich Datenstrukturen als PHP-Dateien cachen.
<?php
$wert = "42";
var_dump($wert);
/* string(2) "42" */
print_r($wert);
/* 42 */
var_export($wert);
/* '42' */
?>
var_export() als Cache-Werkzeug
Ein praktischer Anwendungsfall für var_export() ist das Speichern von Arrays als PHP-Dateien. Dieses Pattern nutzen viele Frameworks intern für Konfigurationscaches.
<?php
$config = [
'db_host' => 'localhost',
'db_name' => 'shop',
'cache' => true,
];
/* Array als PHP-Datei speichern */
file_put_contents(
'cache/config.php',
'<?php return '
. var_export($config, true)
. ';'
);
/* Spaeter wieder laden */
$config = include 'cache/config.php';
?>
Vom var_dump() zum Breakpoint
var_dump() ist der Einstieg ins Debugging, aber bei komplexen Problemen stößt man damit an Grenzen. Man muss den Code ändern, die Seite neu laden und die Ausgabe suchen. Xdebug bietet mit Breakpoints eine komfortablere Alternative: Man setzt einen Haltepunkt in der IDE, und der Code stoppt an dieser Stelle. Dann kann man alle Variablen inspizieren, ohne eine einzige Zeile Code zu ändern. Xdebug lässt sich in PhpStorm und VS Code integrieren.
Zusammenfassung
var_dump() ist das Standardwerkzeug zum Debugging in PHP. Es zeigt Datentyp, Wert und bei komplexen Strukturen die vollständige Hierarchie. Besonders wertvoll ist die Funktion bei der Unterscheidung von null, false, 0 und leeren Strings. Xdebug verändert die Ausgabe und begrenzt die Tiefe, was man bei der Fehlersuche beachten sollte. Für eine kompaktere Darstellung ohne Typ-Informationen eignet sich print_r(), für Code-Generierung var_export().
