var exporter

Componente VarExportador

O componente VarExporter fornece diversas ferramentas para lidar com o estado interno dos objetos:

• VarExporter::export() permite exportar qualquer estrutura de dados PHP serializável para código PHP simples. Ao fazer isso, preserva toda a semântica associada ao mecanismo de serialização do PHP ( __wakeup , __sleep , Serializable , __serialize , __unserialize );
• Instantiator::instantiate() cria um objeto e define suas propriedades sem chamar seu construtor nem qualquer outro método;
• Hydrator::hydrate() pode definir as propriedades de um objeto existente;
• Lazy*Trait pode fazer uma classe se comportar como um fantasma de carregamento lento ou proxy virtual.

VarExportador::exportar()

A razão para usar VarExporter::export() vs serialize() ou igbinary é o desempenho: graças ao OPcache, o código resultante é significativamente mais rápido e mais eficiente em termos de memória do que usar unserialize() ou igbinary_unserialize() .

Ao contrário de var_export() , isso funciona em qualquer valor PHP serializável.

Ele também fornece algumas melhorias em relação var_export() / serialize() :

• a saída é compatível com PSR-2;
• a saída pode ser recuada novamente sem atrapalhar r ou n nos dados;
• classes ausentes lançam uma ClassNotFoundException em vez de serem desserializadas para objetos PHP_Incomplete_Class ;
• referências envolvendo instâncias SplObjectStorage , ArrayObject ou ArrayIterator são preservadas;
• As classes Reflection* , IteratorIterator e RecursiveIteratorIterator lançam uma exceção ao serem serializadas (sua versão não serializada está quebrada de qualquer maneira, consulte https://bugs.php.net/76737).

Instanciador e Hidratante

Instantiator::instantiate($class) cria um objeto de uma determinada classe sem chamar seu construtor nem qualquer outro método.

Hydrator::hydrate() define as propriedades de um objeto existente, incluindo objetos privados e protegidos. Por exemplo:

 // 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

O componente fornece dois padrões de carregamento lento: objetos fantasmas e proxies virtuais (consulte https://martinfowler.com/eaaCatalog/lazyLoad.html para referência).

Objetos fantasma funcionam apenas com classes concretas e não internas. No caso genérico, eles não são compatíveis com o uso de fábricas em seu inicializador.

Os proxies virtuais funcionam com classes concretas, abstratas ou internas. Eles fornecem uma API que se parece com os objetos reais e encaminha chamadas para eles. Eles podem causar problemas de identidade porque os proxies podem não ser vistos como equivalentes aos objetos reais que eles fazem proxy.

Devido a este problema de identidade, os objetos fantasmas devem ser preferidos sempre que possível. As exceções lançadas pela classe ProxyHelper podem ajudar a decidir quando ela pode ser usada ou não.

Objetos fantasma e proxies virtuais fornecem implementações para o LazyObjectInterface que permite redefini-los para seu estado inicial ou inicializá-los à força quando necessário. Observe que a redefinição de um objeto fantasma ignora suas propriedades somente leitura. Você deve usar um proxy virtual para redefinir propriedades somente leitura.

LazyGhostTrait

Usando LazyGhostTrait diretamente em suas classes ou usando ProxyHelper::generateLazyGhost() , você pode tornar suas instâncias de carregamento lento. Isso funciona criando essas instâncias vazias e calculando seu estado apenas ao acessar uma propriedade.

 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 pode ser usado para criar proxies virtuais:

 $ 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

• Documentação
• Contribuindo
• Relate problemas e envie solicitações pull no repositório principal do Symfony