The VarDumper component provides mechanisms for walking through any arbitrary PHP variable.

Built on top, it provides a better ``dump()`` function that you can use instead of :phpfunction:`var_dump`.

The VarDumper component creates a global ``dump()`` function that is configured out of the box:

HTML or CLI output is automatically selected based on the current PHP SAPI.

- per object and resource types specialized view to e.g. filter out Doctrine internals

while dumping a single proxy entity, or get more insight on opened files with

:phpfunction:`stream_get_meta_data()`.

- ability to dump internal references, either soft ones (objects or resources)

or hard ones (``=&`` on arrays or objects properties). Repeated occurrences of

the same object/array/resource won't appear again and again anymore. Moreover,

you'll be able to inspect the reference structure of your data.

``dump()`` is just a thin wrapper for :method:`VarDumper::dump() <Symfony\\Component\\VarDumper\\VarDumper::dump>`

so can you also use it directly. You can change the behavior of this function by calling

Its output is a :class:`Data <Symfony\\Component\\VarDumper\\Cloner\\Data>` object that wraps this representation.

A cloner also applies limits when creating the representation, so that the corresponding

Data object could represent only a subset of the cloned variable.

Objects and resources nested in a PHP variable are casted to arrays in the intermediate Data representation.

You can tweak the array representation for each object/resource by hooking a Caster into this process.

The component already includes many casters for base PHP classes and other common classes.

If you want to build your own Caster, you can register one before cloning a PHP variable.

Casters are registered using either a Cloner's constructor or its ``addCasters()`` method::

As you can notice, resource types are prefixed by a ``:`` to prevent colliding with a class name.

Because an object has one main class and potentially many parent classes or interfaces,

many casters can be applied to one object. In this case, casters are called one after the other,

starting from casters bound to the interfaces, the parents classes and then the main class.

Several casters can also be registered for the same resource type/class/interface.

Casters are responsible for returning the properties of the object or resource being cloned in an array.

They are callables that accept four arguments:

- a :class:`Stub <Sumfony\\Component\\VarDumper\\Cloner\\Stub>` object representing

the main properties of the object (class, type, etc.),

For objects, the ``$array`` parameter comes pre-populated with PHP's native ``(array)`` casting operator

or with the return value of ``$object->__debugInfo()`` if the magic method exists.

Then, the return value of one Caster is given as argument to the next Caster in the chain.

When casting with the ``(array)`` operator, PHP prefixes protected properties with a ``\0*\0``

and private ones with the class owning the property: e.g. ``\0Foobar\0`` prefixes all private properties

of objects of type Foobar. Casters follow this convention and add two more prefixes: ``\0~\0`` is used for

virtual properties and ``\0+\0`` for dynamic ones (runtime added properties not in the class declaration).

Although you can, it is best advised not to alter the state of an object while casting it in a Caster.