A few years ago, I was doing a code review and came across something that stopped me cold. A colleague had written about 12 lines of strstr(), explode(), and regex to pull the hostname out of a URL. I was half a second away from typing "PHP has a function for this" in the comments when I opened my own git history and found a similar function I'd written myself about six months earlier. Same approach, same mess, almost the same number of lines.

I closed the tab and thought about it for a minute before I commented.

This is one of those cases where PHP has EXACTLY what you need built right in, and it's been there since PHP 4. We don't think to look for it because "parsing a URL" sounds complicated enough that our brain jumps straight into "regex mode".

PHP Already Did the Hard Part

The function you want is parse_url(). You hand it a URL string, and it hands you back an associative array with every component of that URL broken out for you. No regex, no strstr(), no counting slashes.

Think of a URL like a mailing address. There's a country, a city, a street, a house number, and maybe an apartment number. You wouldn't write a regex to extract the city from an address if the post office would hand you each piece. parse_url() is the post office.

Here's a URL that has every possible component in it so we can see everything at once:

$url = "https://scott:pass@unleashedpodcasts.com:8080/path/to/page?foo=bar&baz=qux#section";

$parts = parse_url($url);
var_dump($parts);

That gives you back an array that looks like this:

array(8) {
  ["scheme"]=>
  string(5) "https"
  ["host"]=>
  string(21) "unleashedpodcasts.com"
  ["port"]=>
  int(8080)
  ["user"]=>
  string(5) "scott"
  ["pass"]=>
  string(4) "pass"
  ["path"]=>
  string(13) "/path/to/page"
  ["query"]=>
  string(15) "foo=bar&baz=qux"
  ["fragment"]=>
  string(7) "section"
}

We got all eight components with zero regex. Access whatever you need using standard array access: $parts["host"], $parts["scheme"], $parts["path"]. That's it.

Grabbing a Single Component

If you only need one piece of the URL, you don't have to parse the whole thing and then pluck a key. Pass a second argument to tell PHP exactly what you want:

// returns: "unleashedpodcasts.com"
$host = parse_url("https://unleashedpodcasts.com/path?foo=bar", PHP_URL_HOST);

The constants available are PHP_URL_SCHEME, PHP_URL_HOST, PHP_URL_PORT, PHP_URL_USER, PHP_URL_PASS, PHP_URL_PATH, PHP_URL_QUERY, and PHP_URL_FRAGMENT. Each one maps to the key you'd expect from the full array.

This is the version I reach for most often. When I want the hostname, I don't need the whole array sitting in memory.

The Query String Combo

The query key from parse_url() gives you the raw query string: foo=bar&baz=qux. That's still not super useful on its own. To turn it into an actual array of parameters, combine it with parse_str():

$url = 'https://unleashedpodcasts.com/search?category=php&page=3&sort=newest';

parse_str(parse_url($url, PHP_URL_QUERY), $params);

// $params is now:
// ['category' => 'php', 'page' => '3', 'sort' => 'newest']

echo $params['category']; // php
echo $params['page'];     // 3

Note that parse_str() populates the second argument by reference rather than returning a value, so you pass the variable you want to fill as the second argument. A little unusual, but you get used to it fast.

This combo covers about 90% of the URL parsing I do day to day.

A Few Things to Keep in Mind

parse_url() is great, but it has a few quirks worth knowing before you ship code that depends on it.

Not every key will be there. If you parse a relative URL like /path/only, there's no scheme or host, so those keys won't exist in the returned array at all. PHP won't give you an empty string for them instead, the key just won't be set. Always use isset() or the null coalescing operator to stay safe:

$parts = parse_url('/path/only');

$host = $parts['host'] ?? null;    // null, not an error
$scheme = $parts['scheme'] ?? 'https'; // fall back to a default

Skipping this check is an easy way to introduce an Undefined index notice that only shows up in production when someone submits a weird URL. Not that I've ever done such a thing.

It can return false. On a malformed URL, parse_url() doesn't return an empty array, it returns false. So before you start accessing keys, check for that:

$parts = parse_url($url);

if ($parts === false) {
    // handle the error, don't try to use $parts
}

This is easy to miss because most URLs you test with during development are well-formed. The malformed ones show up when users paste something from a chat app or a mangled redirect.

It parses structure, not correctness. parse_url() will return an array for something like not-really-a-url://whatever/stuff. It's doing structural parsing, not validation. If you need to confirm that a URL is valid and reachable, you need filter_var($url, FILTER_VALIDATE_URL) for basic validation, or an HTTP request if you need to confirm it resolves.

The Bottom Line

The next time you find yourself reaching for explode('/', $url) or writing a regex to find the ? in a URL, stop and call parse_url() instead. It handles edge cases that your regex won't, it's readable to every PHP developer on your team, and it's been available for longer than most of us have been writing PHP.

And if you need the query parameters as an array, chain parse_str() onto it. That's the whole pattern.

My colleague's 12-line URL parser is down to two lines now. I'm glad I waited a minute before commenting.