PHP does not have a built-in WeakMap but offers WeakReference for similar functionality. 1. WeakReference allows holding references without preventing garbage collection. 2. It is useful for caching, event listeners, and metadata without affecting object lifecycles. 3. You can simulate a WeakMap using WeakReference with spl_object_hash. 4. Limitations include manual mapping and limited framework support. 5. Use cases include memoization, event systems, and ORMs where memory leaks must be avoided.

PHP doesn't have a built-in WeakMap implementation like JavaScript or Java, but it does offer the WeakReference class (introduced in PHP 7.4) which provides similar behavior. So if you're asking about weak references and WeakMaps in PHP, what we're really talking about is how to use WeakReference to mimic some of the functionality.

What is a Weak Reference?

A weak reference is a reference to an object that doesn’t prevent the object from being garbage collected. In contrast, a normal (or strong) reference keeps an object alive as long as that reference exists.

In PHP, WeakReference allows you to hold a reference to an object without increasing its reference count. Once the original object has no more strong references pointing to it, it becomes eligible for garbage collection — even if there are still WeakReference instances pointing to it.

This is useful when you want to associate data with objects without affecting their lifecycle.

When Might You Use It?

There are a few specific cases where using WeakReference can be helpful:

• Caching or memoization tied to object lifetimes
• Event listeners or observers that shouldn’t keep objects alive
• ORMs or DI containers that need temporary metadata

Let’s look at some practical examples.

Caching Data Without Keeping Objects Alive

Imagine you're building a system where you want to cache computed values based on certain objects — say, a user profile image URL derived from a User object. If you store these in a regular array or map, the User objects won't be garbage collected even after they're no longer needed elsewhere in your app.

Using WeakReference, you can build a kind of "cache" that automatically clears itself when the associated object is destroyed.

$cache = [];

function getProfileUrl(object $user): string {
    global $cache;

    $hash = spl_object_hash($user);

    if (isset($cache[$hash])) {
        return $cache[$hash];
    }

    // Simulate expensive computation
    $url = 'https://example.com/profile/' . md5($user->id);

    $cache[$hash] = $url;
    return $url;
}

To make this weak, wrap the object with WeakReference:

$cache = [];

$user = new User(123);
$ref = WeakReference::create($user);

$cache[spl_object_hash($user)] = $ref;

// Later...
if ($cache['some_hash']->get()) {
    echo 'Still around!';
} else {
    echo 'Already gone.';
}

This way, once $user goes out of scope, the cached entry becomes irrelevant and doesn’t block garbage collection.

Managing Event Listeners Without Memory Leaks

Another common case is event systems where listeners might be registered against long-lived objects. If those listeners hold strong references to short-lived objects, it can cause memory leaks.

By using WeakReference, you can ensure that listeners don’t keep objects alive unnecessarily.

For example:

class EventManager {
    private $listeners = [];

    public function addListener(object $target, callable $callback) {
        $hash = spl_object_hash($target);
        $this->listeners[$hash] = WeakReference::create($target);
        // Store callback logic here...
    }

    public function triggerEvent() {
        foreach ($this->listeners as $hash => $ref) {
            $target = $ref->get();
            if ($target === null) {
                unset($this->listeners[$hash]);
                continue;
            }
            // Call callback if target still exists
        }
    }
}

This avoids keeping $target alive just because it's listening to an event.

Limitations and Alternatives

While WeakReference is powerful, it has limitations:

• No native WeakMap — you must manage the mapping yourself using spl_object_hash
• Not all frameworks or libraries support or expect weak references
• Debugging issues related to object lifetime can be tricky

If you're looking for a more structured approach, some packages provide WeakMap-like implementations by combining WeakReference and associative arrays. These are often used internally in ORMs or container libraries.

So while PHP doesn't have a full WeakMap like other languages, WeakReference gives you enough power to simulate it. Use it when you want to tie data to objects without interfering with their natural lifecycle — things like caches, metadata, or observer patterns benefit most.

It's not something you'll reach for every day, but when you need it, it's exactly what you need.

The above is the detailed content of What are weak references (WeakMap) in PHP, and when might they be useful?. For more information, please follow other related articles on the PHP Chinese website!