Lazy Objects (PHP 8.4)

Also Known As

TL;DR

Explanation

PHP 8.4 adds ReflectionClass::newLazyProxy() and ReflectionClass::newLazyGhost() to the core. A lazy ghost is the real object class with initialisation deferred; a lazy proxy wraps a real instance created on demand. Both defer expensive construction (DB connections, API clients, heavy config parsing) until the first property access or method call. This is the pattern that DI containers have implemented manually for years — now it is a first-class language feature.

Common Misconception

Why It Matters

Common Mistakes

• Using lazy objects for services that are always accessed — the proxy overhead is wasted if initialisation always happens.
• Not understanding that lazy ghost requires the real class, while lazy proxy can wrap any compatible class.
• Serialising lazy objects before initialisation — behaviour depends on whether the object has been triggered.
• Triggering initialisation in the constructor of the surrounding class — defeats the purpose.

Code Examples

// Eager construction — all services built even if unused:
class OrderController {
    public function __construct(
        private ReportingService $reporting,  // Heavy — connects to BI DB
        private AuditService $audit,          // Heavy — reads config files
        private NotificationService $notify,  // Heavy — loads templates
    ) {} // All three built on every request, even simple reads
}

// PHP 8.4 lazy proxy — only constructed if accessed:
$container->bind(ReportingService::class, function() {
    $reflector = new ReflectionClass(ReportingService::class);
    return $reflector->newLazyProxy(
        fn() => new ReportingService($this->get(BiDatabase::class))
    );
});
// OrderController receives the proxy
// ReportingService only constructed when $this->reporting->method() called

References

• ↗ https://wiki.php.net/rfc/lazy-objects

Tags

Related Terms