Beim Entwickeln von PHP-Anwendungen willst du häufig wissen, welche Werte in einem Array oder Objekt stecken. print_r() gibt dir genau diese Information in einem Format, das du als Mensch sofort lesen kannst. Die Funktion ist eines der ältesten und meistgenutzten Debugging-Werkzeuge in PHP.
Was ist print_r() und wofür braucht man es?
Die PHP-Funktion print_r() gibt die Struktur und den Inhalt von Variablen in einem menschenlesbaren Format aus. Sie zeigt bei Arrays alle Schlüssel und Werte, bei Objekten alle öffentlichen Eigenschaften und bei einfachen Variablen den Wert selbst.
Im Vergleich zu var_dump() ist die Ausgabe kompakter und übersichtlicher, zeigt aber keine Typinformationen an. Für einen schnellen Überblick über den Inhalt einer Variable ist print_r() die erste Wahl.
Syntax und Parameter
Der Funktionsaufruf ist einfach gehalten und bietet mit dem optionalen zweiten Parameter eine wichtige Steuerungsmöglichkeit.
print_r(mixed $value, bool $return = false): string|true
Parameter:
$value (mixed, erforderlich): Die Variable, deren Inhalt du sehen möchtest. Kann ein Array, Objekt, String, Integer, Float, Boolean oder null sein.
$return (bool, optional, Standard: false):
false: Die Ausgabe wird direkt an den Browser oder die Konsole gesendet. Rückgabewert ist true.true: Die Ausgabe wird als String zurückgegeben, statt sie direkt auszugeben. Das ist entscheidend für Logging und Weiterverarbeitung.
Grundlegende Beispiele
Die folgenden Beispiele zeigen, wie print_r() verschiedene Datentypen darstellt.
Einfache Variablen
<?php
print_r("Hello World");
// Hello World
print_r(42);
// 42
print_r(3.14);
// 3.14
print_r(true);
// 1
print_r(false);
// (keine Ausgabe)
print_r(null);
// (keine Ausgabe)
Beachte: Bei false und null gibt print_r() nichts aus. Wenn du den Datentyp sehen willst, verwende stattdessen var_dump().
Arrays
Bei Arrays zeigt print_r() seine Stärke: Die verschachtelte Struktur wird eingerueckt und ist sofort lesbar.
<?php
$aObst = [
'a' => 'Apfel',
'c' => 'Clementine',
'd' => ['x', 'y', 'z']
];
print_r($aObst);
Ausgabe:
Array
(
[a] => Apfel
[c] => Clementine
[d] => Array
(
[0] => x
[1] => y
[2] => z
)
)
In Schleifen verwenden
Du kannst print_r() innerhalb von foreach-Schleifen verwenden, um den Inhalt jedes Elements zu prüfen. Das hilft besonders beim Debugging.
<?php
$aUser = [
['name' => 'Anna', 'alter' => 28],
['name' => 'Tom', 'alter' => 35]
];
foreach ($aUser as $iKey => $aEintrag) {
echo "--- Eintrag $iKey ---" . PHP_EOL;
print_r($aEintrag);
}
Der Return-Modus: print_r($var, true)
Im Standardmodus gibt print_r() die Ausgabe direkt aus. Mit dem zweiten Parameter true wird die Ausgabe stattdessen als String zurückgegeben. Das ermöglicht dir, die Ausgabe zu speichern, zu loggen oder weiterzuverarbeiten.
<?php
$aConfig = ['debug' => true, 'port' => 8080];
/* Direkte Ausgabe */
print_r($aConfig);
/* Als String speichern */
$sAusgabe = print_r($aConfig, true);
/* Jetzt kannst du $sAusgabe
beliebig verwenden */
echo "Config: " . $sAusgabe;
Der Return-Modus ist die Grundlage für zwei wichtige Patterns: das Speichern in Logdateien und die formatierte Browserausgabe.
Browser-Formatierung mit pre-Tags
Im Browser werden Zeilenumbrüche und Einrückungen normalerweise ignoriert. Die Ausgabe von print_r() wird dadurch unlesbar, weil alles in einer Zeile erscheint. Die Lösung: Umschließe die Ausgabe mit <pre>-Tags.
<?php
$aDaten = [
'users' => ['Anna', 'Tom'],
'count' => 2
];
/* Ohne pre: alles in einer Zeile */
print_r($aDaten);
/* Mit pre: formatiert und lesbar */
echo '<pre>';
print_r($aDaten);
echo '</pre>';
/* Oder kompakt: */
echo '<pre>' . print_r($aDaten, true) . '</pre>';
In der CLI (Kommandozeile) sind <pre>-Tags nicht nötig, da die Konsole Zeilenumbrüche und Leerzeichen korrekt darstellt.
Sicheres Debugging mit error_log() und print_r()
Das wichtigste Pattern für den professionellen Einsatz von print_r() ist die Kombination mit error_log(). Damit schreibst du die Ausgabe in die PHP-Logdatei, ohne dass der Benutzer etwas davon sieht.
<?php
$aWarenkorb = [
['produkt' => 'Laptop', 'preis' => 999],
['produkt' => 'Maus', 'preis' => 29]
];
/* Array-Inhalt in die Logdatei
schreiben (nicht sichtbar
fuer den Benutzer) */
error_log(
'Warenkorb: '
. print_r($aWarenkorb, true)
);
Die Logeinträge findest du in der Datei, die in der php.ini unter error_log konfiguriert ist. Bei Apache liegt sie häufig unter /var/log/apache2/error.log, bei PHP-FPM unter /var/log/php-fpm/error.log. Du kannst den Pfad mit ini_get('error_log') abfragen.
<?php
/* Wo landen die Logs? */
echo ini_get('error_log');
/* Eigene Logdatei verwenden */
ini_set('error_log', '/tmp/debug.log');
error_log(
'Session: '
. print_r($_SESSION, true)
);
Dieses Pattern ist die einzig sichere Methode, um Variablen in einer Produktionsumgebung zu debuggen. Die Fehlerausgabe im Browser sollte dort immer deaktiviert sein.
print_r() mit Objekten
print_r() zeigt bei Objekten alle öffentlichen Eigenschaften an. Private und geschützte Eigenschaften werden nicht ausgegeben. Das ist ein wichtiger Unterschied zu var_dump(), das alle Eigenschaften inklusive Sichtbarkeit anzeigt.
<?php
class Benutzer
{
public string $name = 'Anna';
public int $alter = 28;
protected string $email = 'a@b.de';
private string $passwort = 'geheim';
}
$oUser = new Benutzer();
print_r($oUser);
Ausgabe:
Benutzer Object
(
[name] => Anna
[alter] => 28
)
Die geschützten und privaten Eigenschaften $email und $passwort fehlen in der Ausgabe. Wenn du alle Eigenschaften sehen willst, verwende var_dump().
__debugInfo() für kontrollierte Ausgabe
Ab PHP 5.6 kannst du mit der Magic Method __debugInfo() steuern, was print_r() und var_dump() anzeigen. Das ist nützlich, um sensible Daten aus der Debug-Ausgabe auszuschließen.
<?php
class ApiClient
{
private string $apiKey;
private string $baseUrl;
private int $requestCount = 0;
public function __construct(
string $apiKey,
string $baseUrl
) {
$this->apiKey = $apiKey;
$this->baseUrl = $baseUrl;
}
public function __debugInfo(): array
{
return [
'baseUrl' => $this->baseUrl,
'requestCount' => $this->requestCount,
'apiKey' => '***versteckt***'
];
}
}
$oClient = new ApiClient(
'sk-geheimer-schluessel',
'https://api.example.com'
);
print_r($oClient);
Ausgabe:
ApiClient Object
(
[baseUrl] => https://api.example.com
[requestCount] => 0
[apiKey] => ***versteckt***
)
Stolperfalle: Zirkuläre Referenzen
Wenn ein Array oder Objekt auf sich selbst verweist, erkennt print_r() die Rekursion und bricht mit dem Hinweis *RECURSION* ab, statt in eine Endlosschleife zu geraten.
<?php
$a = ['name' => 'Test'];
$a['selbst'] =& $a;
print_r($a);
Ausgabe:
Array
(
[name] => Test
[selbst] => Array
(
*RECURSION*
)
)
Das kommt in der Praxis vor, wenn Objekte bidirektionale Beziehungen haben (z.B. ein Eltern-Objekt verweist auf Kind-Objekte und umgekehrt). Die *RECURSION*-Meldung ist kein Fehler, sondern ein Schutzmechanismus.
Warnung: print_r() niemals in Produktion sichtbar verwenden
print_r()-Ausgaben auf einer Live-Webseite sind ein Sicherheitsrisiko. Sie können interne Datenstrukturen offenlegen: Datenbankfelder, Session-Inhalte, API-Schlüssel oder Dateipfade. Ein Angreifer erhält dadurch wertvolle Informationen über deine Anwendung.
<?php
/* FALSCH: Debug-Ausgabe auf
der Live-Webseite */
echo '<pre>';
print_r($_SESSION);
echo '</pre>';
/* Zeigt Session-Daten oeffentlich! */
/* RICHTIG: In die Logdatei
schreiben */
error_log(
'Session: '
. print_r($_SESSION, true)
);
Faustregel: Verwende print_r() direkt nur während der Entwicklung. In Produktion immer den Return-Modus mit error_log() nutzen. Stelle sicher, dass display_errors in der php.ini auf Off steht.
Entscheidungshilfe: print_r() vs. var_dump() vs. var_export()
PHP bietet mehrere Funktionen zur Ausgabe von Variablen. Jede hat ihre Stärke für einen bestimmten Einsatzzweck.
| Funktion | Zeigt Typen | Lesbarkeit | Return-Modus | Bester Einsatz |
| print_r() | Nein | Sehr gut | Ja | Logging, schnelle Inspektion |
| var_dump() | Ja | Gut | Nein* | Detailliertes Debugging |
| var_export() | Nein | Gut | Ja | Code-Generierung, Caching |
* var_dump() hat keinen eingebauten Return-Modus. Du kannst aber ob_start() und ob_get_clean() verwenden, um die Ausgabe abzufangen.
Empfehlung je nach Situation:
- Schneller Blick auf Array-Inhalte:
print_r(). Kompakt und übersichtlich. - Typfehler aufspüren:
var_dump(). Zeigt dir, ob ein Wert "42" (String) oder 42 (Integer) ist. - Logdatei schreiben:
error_log(print_r($var, true)). Der Return-Modus macht print_r() hier zur besten Wahl. - Daten als PHP-Code speichern:
var_export(). Erzeugt gültigen PHP-Code für Konfigurationsdateien.
<?php
$aTest = ['name' => 'Test', 'aktiv' => true];
/* print_r: kompakt, keine Typen */
print_r($aTest);
/* Array ( [name] => Test
[aktiv] => 1 ) */
/* var_dump: mit Typen und Laenge */
var_dump($aTest);
/* array(2) {
["name"]=> string(4) "Test"
["aktiv"]=> bool(true)
} */
/* var_export: gueltiger PHP-Code */
var_export($aTest);
/* array ( 'name' => 'Test',
'aktiv' => true, ) */
Moderne Alternativen zum Debugging
print_r() ist ein bewährtes Werkzeug, aber für professionelle Entwicklung gibt es leistungsfähigere Alternativen.
Xdebug: Step-Debugging in der IDE
Xdebug ist eine PHP-Extension, die dir ermöglicht, Code Zeile für Zeile in deiner IDE (z.B. PhpStorm, VS Code) durchzugehen. Du kannst Breakpoints setzen und den Inhalt jeder Variable in Echtzeit inspizieren, ohne eine einzige Zeile Debug-Code zu schreiben. Für professionelle Entwicklung ist Xdebug die beste Lösung.
Symfony VarDumper und dd()
Das Paket symfony/var-dumper bietet mit dump() und dd() eine farbige, klappbare HTML-Ausgabe, die print_r() und var_dump() in jeder Hinsicht überlegen ist. In Laravel ist es standardmäßig enthalten.
/* Installation: */
// composer require symfony/var-dumper
/* Verwendung: */
dump($aWarenkorb);
/* Farbige, klappbare Ausgabe */
dd($aWarenkorb);
/* Dump and Die: Ausgabe +
Script-Abbruch */
JSON als Debug-Ausgabe
In API-Kontexten oder bei AJAX-Requests ist json_encode() mit JSON_PRETTY_PRINT oft praktischer als print_r(), weil die Ausgabe direkt im Browser-Netzwerk-Tab lesbar ist.
<?php
$aDaten = ['status' => 'ok', 'count' => 5];
/* Fuer API-Debugging: */
header('Content-Type: application/json');
echo json_encode(
$aDaten,
JSON_PRETTY_PRINT
);
Häufige Fragen (FAQ)
Hier findest du Antworten auf die am häufigsten gestellten Fragen zu print_r().
Kann man mehr als eine Variable mit print_r() ausgeben?
print_r() akzeptiert immer nur eine Variable pro Aufruf. Wenn du mehrere Variablen inspizieren willst, rufe die Funktion mehrfach auf oder packe die Variablen in ein Array: print_r(compact('var1', 'var2')).
Warum zeigt print_r() bei false und null nichts an?
print_r() gibt false als leeren String und null ebenfalls als nichts aus. Das ist ein bekanntes Verhalten. Verwende var_dump(), wenn du diese Werte sehen willst. var_dump(false) zeigt bool(false) und var_dump(null) zeigt NULL.
Was bedeutet *RECURSION* in der Ausgabe?
Diese Meldung erscheint, wenn ein Array oder Objekt auf sich selbst verweist (zirkuläre Referenz). print_r() erkennt die Rekursion und bricht ab, statt in eine Endlosschleife zu geraten. Das ist kein Fehler, sondern ein Schutzmechanismus.
Wann print_r() statt var_dump()?
Verwende print_r(), wenn du einen schnellen, übersichtlichen Blick auf Array-Inhalte brauchst oder die Ausgabe per error_log() in eine Logdatei schreiben willst. Verwende var_dump(), wenn du Typinformationen brauchst (z.B. ob ein Wert String oder Integer ist).
Zusammenfassung
print_r() ist eines der meistgenutzten Debugging-Werkzeuge in PHP. Die Funktion zeigt den Inhalt von Arrays und Objekten in einem menschenlesbaren Format an. Mit dem Return-Modus (print_r($var, true)) kannst du die Ausgabe als String speichern und per error_log() sicher in Logdateien schreiben.
Für die tägliche Arbeit merke dir drei Dinge: Erstens, verwende <pre>-Tags für formatierte Browser-Ausgaben. Zweitens, nutze den Return-Modus mit error_log() für Produktions-Debugging. Drittens, verwende var_dump(), wenn du Typinformationen brauchst, und var_export(), wenn du gültigen PHP-Code erzeugen willst.
