symfony/var-dumper

The `symfony/var-dumper` component is a powerful and highly readable variable dumper for PHP, designed to be a superior replacement for native PHP functions like `var_dump()` and `print_r()`. It provides detailed, colorized, and often interactive output of any PHP variable, making debugging significantly easier and more efficient, especially in complex applications.

Key Features and Benefits:

1. Rich Output: Unlike `var_dump()`, `symfony/var-dumper` provides much more context. For objects, it shows the class name, file where the object was defined, and detailed information about properties (visibility, type, value, and even if they are dynamic properties). For arrays, it shows the count and detailed content.
2. Readability: The output is colorized (for both CLI and HTML output), indented, and formatted to be highly human-readable. In a web browser, the HTML output is interactive, allowing you to collapse and expand nested structures, making it easy to navigate large or complex data.
3. `dump()` and `dd()` Functions: The component primarily provides two global functions once included: `dump()` (dumps the variable(s) and continues script execution) and `dd()` (dumps the variable(s) and then terminates script execution, similar to Laravel's `dd()` which is powered by this component).
4. CLI and HTML Support: It automatically detects whether it's running in a command-line interface or a web browser and formats its output accordingly. CLI output uses ANSI escape codes for coloring, while browser output uses sophisticated HTML and CSS.
5. Standalone Usage: While it's a core component of the Symfony framework, `symfony/var-dumper` can be used completely independently in any PHP project by simply requiring it via Composer.
6. Custom Dumper for Resources: It includes special handling for various PHP resources (like database connections, file handles, etc.), providing meaningful information instead of just 'resource id #X'.
7. Less Verbose by Default: By default, it might collapse large arrays or objects to prevent overwhelming the output, but you can always expand them in the browser or configure deeper inspection.

To use it, you typically install it via Composer (`composer require symfony/var-dumper`) and then ensure Composer's autoloader is included in your script. The global `dump()` and `dd()` functions become available for immediate use.

<?php

require 'vendor/autoload.php';

use Symfony\Component\VarDumper\VarDumper;

// A simple class to demonstrate object dumping
class Product
{
    private string $name;
    public float $price;
    protected array $tags;

    public function __construct(string $name, float $price, array $tags)
    {
        $this->name = $name;
        $this->price = $price;
        $this->tags = $tags;
    }

    public function getName(): string
    {
        return $this->name;
    }
}

$product = new Product('Super Widget', 29.99, ['electronics', 'gadget']);
$data = [
    'user_id' => 123,
    'username' => 'john.doe',
    'email' => 'john.doe@example.com',
    'is_active' => true,
    'roles' => ['admin', 'editor'],
    'last_login' => new DateTime(),
    'product' => $product,
    'null_value' => null
];

$simpleString = 'Hello, symfony/var-dumper!';
$anInteger = 42;
$aBoolean = false;

echo "<h1>Demonstrating symfony/var-dumper</h1>";

echo "<h2>Dumping a simple string:</h2>";
dump($simpleString);

echo "<h2>Dumping an integer:</h2>";
dump($anInteger);

echo "<h2>Dumping a boolean:</h2>";
dump($aBoolean);

echo "<h2>Dumping a complex array:</h2>";
dump($data);

echo "<h2>Dumping an object (Product instance):</h2>";
dump($product);

echo "<h2>Using dd() - this will terminate the script after dumping:</h2>";
dd('This is the last thing you will see.');

echo "<p>This line will NOT be executed because dd() terminates the script.</p>";

?>