var exporter

Componente VarExporter

El componente VarExporter proporciona varias herramientas para lidiar con el estado interno de los objetos:

• VarExporter::export() permite exportar cualquier estructura de datos PHP serializable a código PHP simple. Al hacerlo, conserva toda la semántica asociada con el mecanismo de serialización de PHP ( __wakeup , __sleep , Serializable , __serialize , __unserialize );
• Instantiator::instantiate() crea un objeto y establece sus propiedades sin llamar a su constructor ni a ningún otro método;
• Hydrator::hydrate() puede establecer las propiedades de un objeto existente;
• Lazy*Trait puede hacer que una clase se comporte como un fantasma de carga diferida o un proxy virtual.

VarExporter::exportar()

La razón para usar VarExporter::export() vs serialize() o igbinary es el rendimiento: gracias a OPcache, el código resultante es significativamente más rápido y más eficiente en memoria que usar unserialize() o igbinary_unserialize() .

A diferencia de var_export() , esto funciona con cualquier valor PHP serializable.

También proporciona algunas mejoras sobre var_export() / serialize() :

• la salida es compatible con PSR-2;
• la salida se puede volver a sangrar sin alterar r o n en los datos;
• las clases faltantes arrojan una ClassNotFoundException en lugar de no ser serializadas en objetos PHP_Incomplete_Class ;
• se conservan las referencias que involucran instancias SplObjectStorage , ArrayObject o ArrayIterator ;
• Las clases Reflection* , IteratorIterator y RecursiveIteratorIterator generan una excepción cuando se serializan (su versión no serializada está rota de todos modos, consulte https://bugs.php.net/76737).

Instanciador e Hidratador

Instantiator::instantiate($class) crea un objeto de la clase dada sin llamar a su constructor ni a ningún otro método.

Hydrator::hydrate() establece las propiedades de un objeto existente, incluidos los privados y protegidos. Por ejemplo:

 // 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 , [ " Bar  privateBarProperty " => $ propertyValue ]);

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

Lazy*Trait

El componente proporciona dos patrones de carga diferida: objetos fantasma y servidores proxy virtuales (consulte https://martinfowler.com/eaaCatalog/lazyLoad.html como referencia).

Los objetos fantasma funcionan sólo con clases concretas y no internas. En el caso genérico, no son compatibles con el uso de fábricas en su inicializador.

Los proxies virtuales funcionan con clases concretas, abstractas o internas. Proporcionan una API que se parece a los objetos reales y les reenvían llamadas. Pueden causar problemas de identidad porque es posible que los servidores proxy no se consideren equivalentes a los objetos reales que representan.

Debido a este problema de identidad, se deben preferir los objetos fantasma cuando sea posible. Las excepciones lanzadas por la clase ProxyHelper pueden ayudar a decidir cuándo se puede usar o no.

Los objetos fantasma y los proxies virtuales proporcionan implementaciones para LazyObjectInterface que permite restablecerlos a su estado inicial o inicializarlos a la fuerza cuando sea necesario. Tenga en cuenta que al restablecer un objeto fantasma se omiten sus propiedades de solo lectura. Debe utilizar un proxy virtual para restablecer las propiedades de solo lectura.

LazyGhostTrait

Al usar LazyGhostTrait directamente en sus clases o al usar ProxyHelper::generateLazyGhost() , puede hacer que sus instancias se puedan cargar de forma diferida. Esto funciona creando estas instancias vacías y calculando su estado solo cuando se accede a una propiedad.

 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
    $ instance -> __construct (... $ dependencies );
    // [...] 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.

LazyProxyTrait

Alternativamente, LazyProxyTrait se puede utilizar para crear servidores proxy virtuales:

 $ 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. 

Recursos

• Documentación
• Contribuyendo
• Informar problemas y enviar Pull Requests en el repositorio principal de Symfony