PHP var_dump() vs print_r(): Print Arrays and Debug

print_r($array) prints an array or object with its keys and values in a readable form. var_dump($value) prints the same structure plus the type and length of every value. Use print_r to see what is in an array, and var_dump when you need to know whether a value is "1" or 1.

<?php
$user = ["name" => "Ada", "age" => 36, "admin" => false, "tags" => ["math", "code"]];

print_r($user);
echo "\n";
var_dump($user);

Compare the two outputs for admin: print_r printed nothing after the arrow, var_dump printed bool(false). That difference is the main reason to reach for var_dump while debugging.

print_r vs var_dump vs var_export

The three functions show the same data with different detail:

<?php
$values = [0, "0", "", null, false, 1.5];

echo "print_r:\n";
print_r($values);

echo "\nvar_dump:\n";
var_dump($values);

echo "\nvar_export:\n";
var_export($values);
echo "\n";

print_r is easiest to read, var_dump is the most precise, and var_export gives you code you can paste back into a file.

Get print_r output as a string

Pass true as the second argument and print_r returns the text instead of printing it. That is how you write an array to a log file or put it inside a larger message.

<?php
$order = ["id" => 1042, "items" => ["book", "pen"], "total" => 18.5];

$text = print_r($order, true);

echo "Order received:\n" . $text;
echo "That was " . strlen($text) . " characters\n";

file_put_contents("debug.log", date("H:i:s") . " " . $text, FILE_APPEND);
echo "Log size: " . filesize("debug.log") . " bytes\n";

var_export($value, true) returns a string in the same way. var_dump always prints, so to capture it you need output buffering: ob_start(); var_dump($x); $text = ob_get_clean();.

Pretty print an array in HTML with pre

In a browser, the line breaks and spaces of print_r collapse into one long line, because HTML ignores whitespace. Wrap the output in <pre> to keep the layout. Run this and look at the Page tab.

<?php
$menu = [
    "Starters" => ["Soup" => 6, "Salad" => 7],
    "Mains" => ["Pasta" => 14, "Risotto" => 15],
];

echo "<h3>Without pre</h3>\n";
print_r($menu);

echo "<h3>With pre</h3>\n";
echo "<pre>" . htmlspecialchars(print_r($menu, true)) . "</pre>\n";

echo "<h3>As JSON</h3>\n";
echo "<pre>" . htmlspecialchars(json_encode($menu, JSON_PRETTY_PRINT)) . "</pre>\n";

htmlspecialchars matters as soon as the data might contain < or &, for example user input: without it the browser would treat that text as HTML. For data you send to JavaScript or an API, the json_encode form is often the most useful.

Dump several values at once

var_dump accepts any number of arguments and prints each in turn, which is quick for comparing two values side by side.

<?php
$fromForm = "42";
$fromDb = 42;

var_dump($fromForm, $fromDb, $fromForm == $fromDb, $fromForm === $fromDb);

The output shows why == says they are equal and === does not: one is string(2) "42", the other int(42).

Print objects

All three functions print objects too. var_dump and print_r mark private and protected properties ([label:Point:private]), which helps when a property seems to be missing.

<?php
class Point
{
    public function __construct(
        public int $x,
        public int $y,
        private string $label = "origin",
    ) {}
}

$p = new Point(3, 4);

print_r($p);
echo "\n";
var_dump($p);

The #1 in the var_dump output is the object's id. Two variables that show the same id point to the same object.

Common mistake: echo on an array

echo turns its argument into a string. An array has no string form, so PHP prints the word Array and raises a warning:

<?php
$colors = ["red", "green", "blue"];
echo $colors;

PHP prints:

Warning: Array to string conversion in /home/index.php on line 3
Array

Print the contents with one of the functions above, or join the values yourself:

<?php
$colors = ["red", "green", "blue"];

echo implode(", ", $colors), "\n";
echo json_encode($colors), "\n";
print_r($colors);

implode is for showing a list to a user, json_encode for logs and APIs, and print_r or var_dump for your own debugging.