wp_parse_url

The timeline below displays how wordpress function wp_parse_url has changed across different WordPress versions. If a version is not listed, refer to the next available version below.

WordPress Version: 6.3

/**
 * A wrapper for PHP's parse_url() function that handles consistency in the return values
 * across PHP versions.
 *
 * PHP 5.4.7 expanded parse_url()'s ability to handle non-absolute URLs, including
 * schemeless and relative URLs with "://" in the path. This function works around
 * those limitations providing a standard output on PHP 5.2~5.4+.
 *
 * Secondly, across various PHP versions, schemeless URLs containing a ":" in the query
 * are being handled inconsistently. This function works around those differences as well.
 *
 * @since 4.4.0
 * @since 4.7.0 The `$component` parameter was added for parity with PHP's `parse_url()`.
 *
 * @link https://www.php.net/manual/en/function.parse-url.php
 *
 * @param string $url       The URL to parse.
 * @param int    $component The specific component to retrieve. Use one of the PHP
 *                          predefined constants to specify which one.
 *                          Defaults to -1 (= return all parts as an array).
 * @return mixed False on parse failure; Array of URL components on success;
 *               When a specific component has been requested: null if the component
 *               doesn't exist in the given URL; a string or - in the case of
 *               PHP_URL_PORT - integer when it does. See parse_url()'s return values.
 */
function wp_parse_url($url, $component = -1)
{
    $to_unset = array();
    $url = (string) $url;
    if (str_starts_with($url, '//')) {
        $to_unset[] = 'scheme';
        $url = 'placeholder:' . $url;
    } elseif (str_starts_with($url, '/')) {
        $to_unset[] = 'scheme';
        $to_unset[] = 'host';
        $url = 'placeholder://placeholder' . $url;
    }
    $parts = parse_url($url);
    if (false === $parts) {
        // Parsing failure.
        return $parts;
    }
    // Remove the placeholder values.
    foreach ($to_unset as $key) {
        unset($parts[$key]);
    }
    return _get_component_from_parsed_url_array($parts, $component);
}

WordPress Version: 6.1

/**
 * A wrapper for PHP's parse_url() function that handles consistency in the return values
 * across PHP versions.
 *
 * PHP 5.4.7 expanded parse_url()'s ability to handle non-absolute URLs, including
 * schemeless and relative URLs with "://" in the path. This function works around
 * those limitations providing a standard output on PHP 5.2~5.4+.
 *
 * Secondly, across various PHP versions, schemeless URLs containing a ":" in the query
 * are being handled inconsistently. This function works around those differences as well.
 *
 * @since 4.4.0
 * @since 4.7.0 The `$component` parameter was added for parity with PHP's `parse_url()`.
 *
 * @link https://www.php.net/manual/en/function.parse-url.php
 *
 * @param string $url       The URL to parse.
 * @param int    $component The specific component to retrieve. Use one of the PHP
 *                          predefined constants to specify which one.
 *                          Defaults to -1 (= return all parts as an array).
 * @return mixed False on parse failure; Array of URL components on success;
 *               When a specific component has been requested: null if the component
 *               doesn't exist in the given URL; a string or - in the case of
 *               PHP_URL_PORT - integer when it does. See parse_url()'s return values.
 */
function wp_parse_url($url, $component = -1)
{
    $to_unset = array();
    $url = (string) $url;
    if ('//' === substr($url, 0, 2)) {
        $to_unset[] = 'scheme';
        $url = 'placeholder:' . $url;
    } elseif ('/' === substr($url, 0, 1)) {
        $to_unset[] = 'scheme';
        $to_unset[] = 'host';
        $url = 'placeholder://placeholder' . $url;
    }
    $parts = parse_url($url);
    if (false === $parts) {
        // Parsing failure.
        return $parts;
    }
    // Remove the placeholder values.
    foreach ($to_unset as $key) {
        unset($parts[$key]);
    }
    return _get_component_from_parsed_url_array($parts, $component);
}

WordPress Version: 5.6

/**
 * A wrapper for PHP's parse_url() function that handles consistency in the return
 * values across PHP versions.
 *
 * PHP 5.4.7 expanded parse_url()'s ability to handle non-absolute url's, including
 * schemeless and relative url's with :// in the path. This function works around
 * those limitations providing a standard output on PHP 5.2~5.4+.
 *
 * Secondly, across various PHP versions, schemeless URLs starting containing a ":"
 * in the query are being handled inconsistently. This function works around those
 * differences as well.
 *
 * @since 4.4.0
 * @since 4.7.0 The `$component` parameter was added for parity with PHP's `parse_url()`.
 *
 * @link https://www.php.net/manual/en/function.parse-url.php
 *
 * @param string $url       The URL to parse.
 * @param int    $component The specific component to retrieve. Use one of the PHP
 *                          predefined constants to specify which one.
 *                          Defaults to -1 (= return all parts as an array).
 * @return mixed False on parse failure; Array of URL components on success;
 *               When a specific component has been requested: null if the component
 *               doesn't exist in the given URL; a string or - in the case of
 *               PHP_URL_PORT - integer when it does. See parse_url()'s return values.
 */
function wp_parse_url($url, $component = -1)
{
    $to_unset = array();
    $url = (string) $url;
    if ('//' === substr($url, 0, 2)) {
        $to_unset[] = 'scheme';
        $url = 'placeholder:' . $url;
    } elseif ('/' === substr($url, 0, 1)) {
        $to_unset[] = 'scheme';
        $to_unset[] = 'host';
        $url = 'placeholder://placeholder' . $url;
    }
    $parts = parse_url($url);
    if (false === $parts) {
        // Parsing failure.
        return $parts;
    }
    // Remove the placeholder values.
    foreach ($to_unset as $key) {
        unset($parts[$key]);
    }
    return _get_component_from_parsed_url_array($parts, $component);
}

WordPress Version: 5.5

/**
 * A wrapper for PHP's parse_url() function that handles consistency in the return
 * values across PHP versions.
 *
 * PHP 5.4.7 expanded parse_url()'s ability to handle non-absolute url's, including
 * schemeless and relative url's with :// in the path. This function works around
 * those limitations providing a standard output on PHP 5.2~5.4+.
 *
 * Secondly, across various PHP versions, schemeless URLs starting containing a ":"
 * in the query are being handled inconsistently. This function works around those
 * differences as well.
 *
 * @since 4.4.0
 * @since 4.7.0 The `$component` parameter was added for parity with PHP's `parse_url()`.
 *
 * @link https://www.php.net/manual/en/function.parse-url.php
 *
 * @param string $url       The URL to parse.
 * @param int    $component The specific component to retrieve. Use one of the PHP
 *                          predefined constants to specify which one.
 *                          Defaults to -1 (= return all parts as an array).
 * @return mixed False on parse failure; Array of URL components on success;
 *               When a specific component has been requested: null if the component
 *               doesn't exist in the given URL; a string or - in the case of
 *               PHP_URL_PORT - integer when it does. See parse_url()'s return values.
 */
function wp_parse_url($url, $component = -1)
{
    $to_unset = array();
    $url = strval($url);
    if ('//' === substr($url, 0, 2)) {
        $to_unset[] = 'scheme';
        $url = 'placeholder:' . $url;
    } elseif ('/' === substr($url, 0, 1)) {
        $to_unset[] = 'scheme';
        $to_unset[] = 'host';
        $url = 'placeholder://placeholder' . $url;
    }
    $parts = parse_url($url);
    if (false === $parts) {
        // Parsing failure.
        return $parts;
    }
    // Remove the placeholder values.
    foreach ($to_unset as $key) {
        unset($parts[$key]);
    }
    return _get_component_from_parsed_url_array($parts, $component);
}

WordPress Version: 5.4

/**
 * A wrapper for PHP's parse_url() function that handles consistency in the return
 * values across PHP versions.
 *
 * PHP 5.4.7 expanded parse_url()'s ability to handle non-absolute url's, including
 * schemeless and relative url's with :// in the path. This function works around
 * those limitations providing a standard output on PHP 5.2~5.4+.
 *
 * Secondly, across various PHP versions, schemeless URLs starting containing a ":"
 * in the query are being handled inconsistently. This function works around those
 * differences as well.
 *
 * Error suppression is used as prior to PHP 5.3.3, an E_WARNING would be generated
 * when URL parsing failed.
 *
 * @since 4.4.0
 * @since 4.7.0 The `$component` parameter was added for parity with PHP's `parse_url()`.
 *
 * @link https://www.php.net/manual/en/function.parse-url.php
 *
 * @param string $url       The URL to parse.
 * @param int    $component The specific component to retrieve. Use one of the PHP
 *                          predefined constants to specify which one.
 *                          Defaults to -1 (= return all parts as an array).
 * @return mixed False on parse failure; Array of URL components on success;
 *               When a specific component has been requested: null if the component
 *               doesn't exist in the given URL; a string or - in the case of
 *               PHP_URL_PORT - integer when it does. See parse_url()'s return values.
 */
function wp_parse_url($url, $component = -1)
{
    $to_unset = array();
    $url = strval($url);
    if ('//' === substr($url, 0, 2)) {
        $to_unset[] = 'scheme';
        $url = 'placeholder:' . $url;
    } elseif ('/' === substr($url, 0, 1)) {
        $to_unset[] = 'scheme';
        $to_unset[] = 'host';
        $url = 'placeholder://placeholder' . $url;
    }
    $parts = @parse_url($url);
    if (false === $parts) {
        // Parsing failure.
        return $parts;
    }
    // Remove the placeholder values.
    foreach ($to_unset as $key) {
        unset($parts[$key]);
    }
    return _get_component_from_parsed_url_array($parts, $component);
}

WordPress Version: 5.1

/**
 * A wrapper for PHP's parse_url() function that handles consistency in the return
 * values across PHP versions.
 *
 * PHP 5.4.7 expanded parse_url()'s ability to handle non-absolute url's, including
 * schemeless and relative url's with :// in the path. This function works around
 * those limitations providing a standard output on PHP 5.2~5.4+.
 *
 * Secondly, across various PHP versions, schemeless URLs starting containing a ":"
 * in the query are being handled inconsistently. This function works around those
 * differences as well.
 *
 * Error suppression is used as prior to PHP 5.3.3, an E_WARNING would be generated
 * when URL parsing failed.
 *
 * @since 4.4.0
 * @since 4.7.0 The `$component` parameter was added for parity with PHP's `parse_url()`.
 *
 * @link https://secure.php.net/manual/en/function.parse-url.php
 *
 * @param string $url       The URL to parse.
 * @param int    $component The specific component to retrieve. Use one of the PHP
 *                          predefined constants to specify which one.
 *                          Defaults to -1 (= return all parts as an array).
 * @return mixed False on parse failure; Array of URL components on success;
 *               When a specific component has been requested: null if the component
 *               doesn't exist in the given URL; a string or - in the case of
 *               PHP_URL_PORT - integer when it does. See parse_url()'s return values.
 */
function wp_parse_url($url, $component = -1)
{
    $to_unset = array();
    $url = strval($url);
    if ('//' === substr($url, 0, 2)) {
        $to_unset[] = 'scheme';
        $url = 'placeholder:' . $url;
    } elseif ('/' === substr($url, 0, 1)) {
        $to_unset[] = 'scheme';
        $to_unset[] = 'host';
        $url = 'placeholder://placeholder' . $url;
    }
    $parts = @parse_url($url);
    if (false === $parts) {
        // Parsing failure.
        return $parts;
    }
    // Remove the placeholder values.
    foreach ($to_unset as $key) {
        unset($parts[$key]);
    }
    return _get_component_from_parsed_url_array($parts, $component);
}

WordPress Version: 4.9

/**
 * A wrapper for PHP's parse_url() function that handles consistency in the return
 * values across PHP versions.
 *
 * PHP 5.4.7 expanded parse_url()'s ability to handle non-absolute url's, including
 * schemeless and relative url's with :// in the path. This function works around
 * those limitations providing a standard output on PHP 5.2~5.4+.
 *
 * Secondly, across various PHP versions, schemeless URLs starting containing a ":"
 * in the query are being handled inconsistently. This function works around those
 * differences as well.
 *
 * Error suppression is used as prior to PHP 5.3.3, an E_WARNING would be generated
 * when URL parsing failed.
 *
 * @since 4.4.0
 * @since 4.7.0 The $component parameter was added for parity with PHP's parse_url().
 *
 * @link https://secure.php.net/manual/en/function.parse-url.php
 *
 * @param string $url       The URL to parse.
 * @param int    $component The specific component to retrieve. Use one of the PHP
 *                          predefined constants to specify which one.
 *                          Defaults to -1 (= return all parts as an array).
 * @return mixed False on parse failure; Array of URL components on success;
 *               When a specific component has been requested: null if the component
 *               doesn't exist in the given URL; a string or - in the case of
 *               PHP_URL_PORT - integer when it does. See parse_url()'s return values.
 */
function wp_parse_url($url, $component = -1)
{
    $to_unset = array();
    $url = strval($url);
    if ('//' === substr($url, 0, 2)) {
        $to_unset[] = 'scheme';
        $url = 'placeholder:' . $url;
    } elseif ('/' === substr($url, 0, 1)) {
        $to_unset[] = 'scheme';
        $to_unset[] = 'host';
        $url = 'placeholder://placeholder' . $url;
    }
    $parts = @parse_url($url);
    if (false === $parts) {
        // Parsing failure.
        return $parts;
    }
    // Remove the placeholder values.
    foreach ($to_unset as $key) {
        unset($parts[$key]);
    }
    return _get_component_from_parsed_url_array($parts, $component);
}

WordPress Version: 4.8

/**
 * A wrapper for PHP's parse_url() function that handles consistency in the return
 * values across PHP versions.
 *
 * PHP 5.4.7 expanded parse_url()'s ability to handle non-absolute url's, including
 * schemeless and relative url's with :// in the path. This function works around
 * those limitations providing a standard output on PHP 5.2~5.4+.
 *
 * Secondly, across various PHP versions, schemeless URLs starting containing a ":"
 * in the query are being handled inconsistently. This function works around those
 * differences as well.
 *
 * Error suppression is used as prior to PHP 5.3.3, an E_WARNING would be generated
 * when URL parsing failed.
 *
 * @since 4.4.0
 * @since 4.7.0 The $component parameter was added for parity with PHP's parse_url().
 *
 * @param string $url       The URL to parse.
 * @param int    $component The specific component to retrieve. Use one of the PHP
 *                          predefined constants to specify which one.
 *                          Defaults to -1 (= return all parts as an array).
 *                          @see http://php.net/manual/en/function.parse-url.php
 * @return mixed False on parse failure; Array of URL components on success;
 *               When a specific component has been requested: null if the component
 *               doesn't exist in the given URL; a string or - in the case of
 *               PHP_URL_PORT - integer when it does. See parse_url()'s return values.
 */
function wp_parse_url($url, $component = -1)
{
    $to_unset = array();
    $url = strval($url);
    if ('//' === substr($url, 0, 2)) {
        $to_unset[] = 'scheme';
        $url = 'placeholder:' . $url;
    } elseif ('/' === substr($url, 0, 1)) {
        $to_unset[] = 'scheme';
        $to_unset[] = 'host';
        $url = 'placeholder://placeholder' . $url;
    }
    $parts = @parse_url($url);
    if (false === $parts) {
        // Parsing failure.
        return $parts;
    }
    // Remove the placeholder values.
    foreach ($to_unset as $key) {
        unset($parts[$key]);
    }
    return _get_component_from_parsed_url_array($parts, $component);
}

WordPress Version: 4.7

/**
 * A wrapper for PHP's parse_url() function that handles consistency in the return
 * values across PHP versions.
 *
 * PHP 5.4.7 expanded parse_url()'s ability to handle non-absolute url's, including
 * schemeless and relative url's with :// in the path. This function works around
 * those limitations providing a standard output on PHP 5.2~5.4+.
 *
 * Secondly, across various PHP versions, schemeless URLs starting containing a ":"
 * in the query are being handled inconsistently. This function works around those
 * differences as well.
 *
 * Error suppression is used as prior to PHP 5.3.3, an E_WARNING would be generated
 * when URL parsing failed.
 *
 * @since 4.4.0
 * @since 4.7.0 The $component parameter was added for parity with PHP's parse_url().
 *
 * @param string $url       The URL to parse.
 * @param int    $component The specific component to retrieve. Use one of the PHP
 *                          predefined constants to specify which one.
 *                          Defaults to -1 (= return all parts as an array).
 *                          @see http://php.net/manual/en/function.parse-url.php
 * @return mixed False on parse failure; Array of URL components on success;
 *               When a specific component has been requested: null if the component
 *               doesn't exist in the given URL; a sting or - in the case of
 *               PHP_URL_PORT - integer when it does. See parse_url()'s return values.
 */
function wp_parse_url($url, $component = -1)
{
    $to_unset = array();
    $url = strval($url);
    if ('//' === substr($url, 0, 2)) {
        $to_unset[] = 'scheme';
        $url = 'placeholder:' . $url;
    } elseif ('/' === substr($url, 0, 1)) {
        $to_unset[] = 'scheme';
        $to_unset[] = 'host';
        $url = 'placeholder://placeholder' . $url;
    }
    $parts = @parse_url($url);
    if (false === $parts) {
        // Parsing failure.
        return $parts;
    }
    // Remove the placeholder values.
    foreach ($to_unset as $key) {
        unset($parts[$key]);
    }
    return _get_component_from_parsed_url_array($parts, $component);
}

WordPress Version: 4.4

/**
 * A wrapper for PHP's parse_url() function that handles edgecases in < PHP 5.4.7
 *
 * PHP 5.4.7 expanded parse_url()'s ability to handle non-absolute url's, including
 * schemeless and relative url's with :// in the path, this works around those
 * limitations providing a standard output on PHP 5.2~5.4+.
 *
 * Error suppression is used as prior to PHP 5.3.3, an E_WARNING would be generated
 * when URL parsing failed.
 *
 * @since 4.4.0
 *
 * @param string $url The URL to parse.
 * @return bool|array False on failure; Array of URL components on success;
 *                    See parse_url()'s return values.
 */
function wp_parse_url($url)
{
    $parts = @parse_url($url);
    if (!$parts) {
        // < PHP 5.4.7 compat, trouble with relative paths including a scheme break in the path
        if ('/' == $url[0] && false !== strpos($url, '://')) {
            // Since we know it's a relative path, prefix with a scheme/host placeholder and try again
            if (!$parts = @parse_url('placeholder://placeholder' . $url)) {
                return $parts;
            }
            // Remove the placeholder values
            unset($parts['scheme'], $parts['host']);
        } else {
            return $parts;
        }
    }
    // < PHP 5.4.7 compat, doesn't detect schemeless URL's host field
    if ('//' == substr($url, 0, 2) && !isset($parts['host'])) {
        $path_parts = explode('/', substr($parts['path'], 2), 2);
        $parts['host'] = $path_parts[0];
        if (isset($path_parts[1])) {
            $parts['path'] = '/' . $path_parts[1];
        } else {
            unset($parts['path']);
        }
    }
    return $parts;
}