ReflectionClass::newLazyGhost

(PHP 8 >= 8.4.0)

ReflectionClass::newLazyGhost — Creates a new lazy ghost instance

Опис

public ReflectionClass::newLazyGhost(callable $initializer, int $options = 0): object

Creates a new lazy ghost instance of the class, attaching the initializer to it. The constructor is not called, and properties are not set to their default value. However, the object will be automatically initialized by invoking the initializer the first time its state is observed or modified. See Initialization Triggers and Initialization Sequence.

Параметри

initializer

The initializer is a callback with the following signature:

initializer(object $object): void

object: The object being initialized. At this point, the object is no longer marked as lazy, and accessing it does not trigger initialization again.

The initializer function must return null or no value.

options

options can be a combination of the following flags:

ReflectionClass::SKIP_INITIALIZATION_ON_SERIALIZE: By default, serializing a lazy object triggers its initialization. Setting this flag prevents initialization, allowing lazy objects to be serialized without being initialized.

Значення, що повертаються

Returns a lazy ghost instance. If the object has no properties, or if all its properties are static or virtual, a normal (non-lazy) instance is returned. See also Lifecycle of Lazy Objects.

Помилки/виключення

An Error if the class is internal or extends an internal class except stdClass.

Приклади

Приклад #1 Basic usage

<?php

class Example {
    public function __construct(public int $prop) {
        echo __METHOD__, "\n";
    }
}

$reflector = new ReflectionClass(Example::class);
$object = $reflector->newLazyGhost(function (Example $object) {
     $object->__construct(1);
});

var_dump($object);
var_dump($object instanceof Example);

// Triggers initialization, and fetches the property after that
var_dump($object->prop);

?>

Поданий вище приклад виведе:

lazy ghost object(Example)#3 (0) {
  ["prop"]=>
  uninitialized(int)
}
bool(true)
Example::__construct
int(1)

Прогляньте також

Lazy objects
ReflectionClass::newLazyProxy() - Creates a new lazy proxy instance
ReflectionClass::newInstanceWithoutConstructor() - Creates a new class instance without invoking the constructor
ReflectionClass::resetAsLazyGhost() - Resets an object and marks it as lazy
ReflectionClass::markLazyObjectAsInitialized() - Marks a lazy object as initialized without calling the initializer or factory
ReflectionClass::initializeLazyObject() - Forces initialization of a lazy object
ReflectionClass::isUninitializedLazyObject() - Checks if an object is lazy and uninitialized
ReflectionProperty::setRawValueWithoutLazyInitialization() - Set raw property value without triggering lazy initialization
ReflectionProperty::skipLazyInitialization() - Marks property as non-lazy
ReflectionProperty::isLazy() - Checks whether a property is lazy

Found A Problem?

Learn How To Improve This Page • Submit a Pull Request • Report a Bug

＋add a note

User Contributed Notes 1 note

down

dave1010 at gmail dot com ¶

1 month ago

Simple helper function that makes it easier to understand:

<?php

function createLazyGhost(
    string $class,
    ?callable $initializer = null,
    ?array $propertySetterCallables = null
): object {
    $reflection = new ReflectionClass($class);

    return $reflection->newLazyGhost(function (object $object) use ($initializer, $propertySetterCallables) {
        // Initialize via the main initializer if provided
        if ($initializer) {
            $initializer($object);
        }

        // Set properties using the callables if provided
        if ($propertySetterCallables) {
            foreach ($propertySetterCallables as $property => $callable) {
                if (is_callable($callable)) {
                    $object->$property = $callable();
                }
            }
        }
    });
}

?>

This supports using either a main object initializer and/or property initializers.

Here's an example, where generating order IDs and calculating totals is considered expensive, so we only do it when necessary:

<?php

class Order {
    public string $orderId = '';
    public float $total = 0.0;
}

$initializer = function (Order $order) {
    $order->orderId = 'ORD12345';
};

$propertySetters = [
    'total' => fn() => 200.75,
];

// Lazy ghost with both an initializer and property callables
$lazyOrder = createLazyGhost(Order::class, $initializer, $propertySetters);

// We can now use $lazyOrder as normal, even though the properties haven't been calculated yet.

// Do something that triggers initialization
echo $lazyOrder->orderId . PHP_EOL;
echo $lazyOrder->total . PHP_EOL;

?>

＋add a note