Multiple Approaches and Best Practices for Extracting the Last Segment of URLs in PHP

URL Structure Analysis and Requirement Definition

In web development, extracting specific segments from URLs is a common requirement, such as obtaining resource identifiers. Consider the following URL example:

http://domain.example/artist/song/music-videos/song-title/9393903

The objective is to extract the numeric identifier 9393903 from the end. URL structures typically consist of protocol, domain, path, and potentially query strings, with identifiers often positioned at the path terminus.

Regular Expression Method: Precise Matching and Capturing

Regular expression-based solutions offer maximum flexibility and precision. The preg_match() function enables definition of specific patterns to match target content:

$url = 'http://domain.example/artist/song/music-videos/song-title/9393903';

if (preg_match("/\/(\d+)$/", $url, $matches)) {
    $end = $matches[1];
    echo $end; // Output: 9393903
} else {
    // Handle matching failure
    echo "URL format does not meet expectations";
}

Analysis of the regular expression /\/(\d+)$/:

• \/: Matches the path separator slash
• (\d+): Captures one or more digit characters
• $: Ensures matching occurs at string end

This approach's strength lies in precise control over matching conditions, allowing pattern extension for URL format validation:

if (preg_match("/^https?:\/\/.*\/(\d+)$/", $url, $matches)) {
    // Validates URL starts with http:// or https://
    $end = $matches[1];
}

Alternative Approaches Comparison and Application Scenarios

basename() Function: Simplicity and Directness

The basename() function provides the most concise solution:

$end = basename('http://example.com/artist/song/music-videos/song-title/9393903');
// Result: 9393903

Note that if the URL contains query strings, basename() includes them in the return:

$end = basename('http://example.com/path/123?param=value');
// Result: 123?param=value

String Splitting Method

Extracting through path segmentation using explode():

$parts = explode('/', rtrim($url, '/'));
$end = end($parts);

Using rtrim() handles potential trailing slashes, ensuring correct segmentation.

parse_url() Combined with Path Parsing

A more robust approach involves first extracting the URL path component:

$path = parse_url($url, PHP_URL_PATH);
$pathFragments = explode('/', trim($path, '/'));
$end = end($pathFragments);

This method isolates the path from other URL components, avoiding interference from protocols and query strings.

Performance Considerations and Error Handling

Different methods exhibit performance variations:

• Regular Expressions: Precise matching but relatively heavy, suitable for complex pattern validation
• String Functions: Generally faster, appropriate for simple segmentation scenarios
• basename(): Optimal performance but limited functionality

Practical applications should incorporate appropriate error handling:

function extractUrlEnd($url, $pattern = '/\/(\d+)$/') {
    if (!is_string($url) || empty($url)) {
        throw new InvalidArgumentException("Invalid URL input");
    }
    
    if (preg_match($pattern, $url, $matches)) {
        return $matches[1];
    }
    
    // Fallback: attempt alternative extraction methods
    $fallback = basename(parse_url($url, PHP_URL_PATH) ?: $url);
    return $fallback !== false ? $fallback : null;
}

Practical Implementation Recommendations

When selecting extraction methods, consider:

1. URL Structure Stability: For fixed and simple URL formats, basename() or string splitting suffices
2. Validation Requirements: Regular expressions are more appropriate when identifier format validation is needed
3. Performance Demands: High-frequency calling scenarios prioritize lightweight solutions
4. Error Tolerance: Critical business logic should implement multi-layer fallback mechanisms

For the example requirement—extracting ending numeric identifiers—the regular expression method provides optimal balance: ensuring precise matching of digit sequences while maintaining good extensibility for future requirement evolution.