Var Exporter

Allows exporting any serializable PHP data structure to plain PHP code
Alternatives To Var Exporter
Project NameStarsDownloadsRepos Using ThisPackages Using ThisMost Recent CommitTotal ReleasesLatest ReleaseOpen IssuesLicenseLanguage
Var Exporter1,8992,588706 days ago151May 27, 2022mitPHP
Allows exporting any serializable PHP data structure to plain PHP code
Foshttpcache3432343220 days ago59November 02, 20229otherPHP
Integrate your PHP application with your HTTP caching proxy
Leezypheanstalkbundle118376a year ago35August 03, 20203mitPHP
Bundle for Pheanstalk - A PHP client for beanstalkd queue
Velocita Proxy45
3 months agomitHTML
Velocita - Composer caching reverse proxy
10 years ago5PHP
CAS bundle (DEPRECATED -- use
a year ago1mitGo
🍏 Simple wrapper to Symfony Go Binary for multi-app
7 years ago3mitPHP
CacheTool Symfony2 Bundle
5 years agomitPHP
Docker sync stack for symfony application (docker+docker-sync+nginx+php7.2-fpm+xdebug)
Datanova Bundle10
3 years ago2mitPHP
:notebook: Symfony bundle to fetch data from LaPoste DataNOVA (Open Data API)
10 years agoMarch 04, 20222mitPHP
[Deprecated] Simple repository proxy for Composer
Alternatives To Var Exporter
Select To Compare

Alternative Project Comparisons

VarExporter Component

The VarExporter component provides various tools to deal with the internal state of objects:

  • VarExporter::export() allows exporting any serializable PHP data structure to plain PHP code. While doing so, it preserves all the semantics associated with the serialization mechanism of PHP (__wakeup, __sleep, Serializable, __serialize, __unserialize.)
  • Instantiator::instantiate() creates an object and sets its properties without calling its constructor nor any other methods.
  • Hydrator::hydrate() can set the properties of an existing object.
  • Lazy*Trait can make a class behave as a lazy-loading ghost or virtual proxy.


The reason to use VarExporter::export() vs serialize() or igbinary is performance: thanks to OPcache, the resulting code is significantly faster and more memory efficient than using unserialize() or igbinary_unserialize().

Unlike var_export(), this works on any serializable PHP value.

It also provides a few improvements over var_export()/serialize():

  • the output is PSR-2 compatible;
  • the output can be re-indented without messing up with \r or \n in the data
  • missing classes throw a ClassNotFoundException instead of being unserialized to PHP_Incomplete_Class objects;
  • references involving SplObjectStorage, ArrayObject or ArrayIterator instances are preserved;
  • Reflection*, IteratorIterator and RecursiveIteratorIterator classes throw an exception when being serialized (their unserialized version is broken anyway, see

Instantiator and Hydrator

Instantiator::instantiate($class) creates an object of the given class without calling its constructor nor any other methods.

Hydrator::hydrate() sets the properties of an existing object, including private and protected ones. For example:

// Sets the public or protected $object->propertyName property
Hydrator::hydrate($object, ['propertyName' => $propertyValue]);

// Sets a private property defined on its parent Bar class:
Hydrator::hydrate($object, ["\0Bar\0privateBarProperty" => $propertyValue]);

// Alternative way to set the private $object->privateBarProperty property
Hydrator::hydrate($object, [], [
    Bar::class => ['privateBarProperty' => $propertyValue],


The component provides two lazy-loading patterns: ghost objects and virtual proxies (see for reference.)

Ghost objects work only with concrete and non-internal classes. In the generic case, they are not compatible with using factories in their initializer.

Virtual proxies work with concrete, abstract or internal classes. They provide an API that looks like the actual objects and forward calls to them. They can cause identity problems because proxies might not be seen as equivalents to the actual objects they proxy.

Because of this identity problem, ghost objects should be preferred when possible. Exceptions thrown by the ProxyHelper class can help decide when it can be used or not.

Ghost objects and virtual proxies both provide implementations for the LazyObjectInterface which allows resetting them to their initial state or to forcibly initialize them when needed. Note that resetting a ghost object skips its read-only properties. You should use a virtual proxy to reset read-only properties.


By using LazyGhostTrait either directly in your classes or by using ProxyHelper::generateLazyGhost(), you can make their instances lazy-loadable. This works by creating these instances empty and by computing their state only when accessing a property.

class FooLazyGhost extends Foo
    use LazyGhostTrait;

$foo = FooLazyGhost::createLazyGhost(initializer: function (Foo $instance): void {
    // [...] Use whatever heavy logic you need here
    // to compute the $dependencies of the $instance
    // [...] Call setters, etc. if needed

// $foo is now a lazy-loading ghost object. The initializer will
// be called only when and if a *property* is accessed.

You can also partially initialize the objects on a property-by-property basis by adding two arguments to the initializer:

$initializer = function (Foo $instance, string $propertyName, ?string $propertyScope): mixed {
    if (Foo::class === $propertyScope && 'bar' === $propertyName) {
        return 123;
    // [...] Add more logic for the other properties


Alternatively, LazyProxyTrait can be used to create virtual proxies:

$proxyCode = ProxyHelper::generateLazyProxy(new ReflectionClass(Foo::class));
// $proxyCode contains the reference to LazyProxyTrait
// and should be dumped into a file in production envs
eval('class FooLazyProxy'.$proxyCode);

$foo = FooLazyProxy::createLazyProxy(initializer: function (): Foo {
    // [...] Use whatever heavy logic you need here
    // to compute the $dependencies of the $instance
    $instance = new Foo(...$dependencies);
    // [...] Call setters, etc. if needed

    return $instance;
// $foo is now a lazy-loading virtual proxy object. The initializer will
// be called only when and if a *method* is called.


Popular Proxy Projects
Popular Symfony Projects
Popular Networking Categories
Related Searches

Get A Weekly Email With Trending Projects For These Categories
No Spam. Unsubscribe easily at any time.
Lazy Loading
Symfony Component