How to cache the results of parse_url to improve performance?

gitbox 2025-05-26

In daily PHP development, parse_url is a very common function that parses URL strings and returns their components. Although this function itself is fast, in some high-frequency calling scenarios, such as when batch processing of large amounts of URLs, frequent repetition of the same URL will cause unnecessary performance overhead.

To avoid this duplicate calculation, we can store the results of parse_url through a cache mechanism. This article will introduce in detail how to cache the results of parse_url in a simple and efficient way to improve the performance of PHP applications.

Why cache the result of parse_url?

Although parse_url is a built-in PHP function and has high execution efficiency, it will still perform string parsing, regular matching and other operations. If a system repeatedly processes the same URL in multiple places, calling parse_url every time is actually a waste. By cached parsing results, you can:

Avoid repeated parsing;
Reduce CPU overhead;
Improve overall performance, especially in cyclic or high-concurrency environments.

Implementation method

Below we provide a simple function encapsulation for memory-level cache processing of the results of parse_url :

 function cached_parse_url(string $url): array|false {
    static $cache = [];

    // Use hash as cache key，avoid URL Too long causes inconsistent array keys
    $key = md5($url);

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

    $parsed = parse_url($url);
    if ($parsed !== false) {
        $cache[$key] = $parsed;
    }

    return $parsed;
}

The core of this function is a static variable $cache , which is shared globally within the scope of the function, so even if the function is called multiple times, the cache will be hit as long as it is the same URL.

Example of usage

 $urls = [
    'https://gitbox.net/path?query=1',
    'https://gitbox.net/path?query=1',
    'https://gitbox.net/otherpath?query=2',
];

foreach ($urls as $url) {
    $parts = cached_parse_url($url);
    print_r($parts);
}

In the example above, although there are three URLs, one of them is duplicate, cached_parse_url will only parse once, and the second time will directly return the cached result.

Extension: APCu-based cache

For larger or cross-request cache requirements, APCu can be used:

 function cached_parse_url_apcu(string $url): array|false {
    $key = 'parsed_url_' . md5($url);

    $cached = apcu_fetch($key);
    if ($cached !== false) {
        return $cached;
    }

    $parsed = parse_url($url);
    if ($parsed !== false) {
        apcu_store($key, $parsed);
    }

    return $parsed;
}

Using apcu allows caches to travel through multiple request lifecycles, suitable for performance optimization of web applications or CLI scripts.

Things to note

parse_url will return false when parse invalid URLs are parsed. It is recommended to judge the results before cache them.
The caching mechanism itself will also occupy memory resources, and it is not recommended to cache one-time URLs.
In multi-threaded or highly concurrent environments, thread safety needs to be ensured if APCu is used.

Conclusion

Although parse_url is a trivial function, its performance consumption cannot be ignored when called at high frequency. By introducing a simple caching mechanism, we can significantly reduce the system's resource overhead while ensuring parsing accuracy. The power of cache can also show great value in details. For PHP projects with performance optimization requirements, this optimization is very worthy of practice.

parse_url