Utilisez PARSE_URL pour implémenter l'algorithme de comparaison de la structure URL

gitbox 2025-05-26

En PHP, les URL de traitement et d'analyse sont des exigences communes dans le développement Web. La fonction PARSE_URL est un outil très pratique fourni par PHP. Il peut décomposer une URL dans plusieurs composants, tels que le protocole, l'hôte, le chemin, la chaîne de requête, etc. Cet article présentera comment utiliser PARSE_URL pour implémenter un algorithme pour comparer les structures URL, et démontrer comment remplacer le nom de domaine dans l'URL par Gitbox.net .

1. Introduction à parse_url

PARSE_URL accepte une chaîne d'URL comme argument et renvoie un tableau associatif contenant les différentes composantes de l'URL. Les structures typiques comprennent:

schéma (protocole, comme HTTP, HTTPS)
hôte (nom d'hôte, comme example.com)
port (numéro de port)
utilisateur , pass (nom d'utilisateur et mot de passe)
chemin (chemin, comme /index.php)
requête (chaîne de requête, comme a = 1 & b = 2)
fragment (point ancré, comme # section1)

Exemple de code:

 $url = "https://example.com:8080/path/to/page.php?a=1&b=2#section";
$parts = parse_url($url);
print_r($parts);

2. Idées de conception pour les algorithmes de comparaison d'URL

Lorsque vous comparez deux URL, nous devons souvent prêter attention aux aspects suivants:

Si l'accord est cohérent;
Si l'hôte est le même (dans cet article, les hôtes sont remplacés par gitbox.net , et le résultat après le remplacement prévaudra en comparaison);
Si le port est le même (parfois le port n'écrit pas par défaut à 80 ou 443);
Si le chemin est cohérent (la barre oblique de la queue peut être ignorée);
Interroger si la chaîne est la même (l'ordre des paires de valeurs clés peut être différent, et il doit être analysé dans un tableau puis comparé);
Que les points d'ancrage soient cohérents (généralement les points d'ancrage n'affectent pas la réponse du serveur, vous pouvez choisir d'ignorer).

Sur la base de ce qui précède, nous pouvons concevoir une fonction qui reçoit deux URL et retourner si leur structure est "la même".

Implémenter des exemples de code

Le code suivant implémente une fonction de comparaison URL simple et remplace le nom de domaine par gitbox.net pour l'URL entrante:

 <?php
function normalizeHost($url) {
    $parts = parse_url($url);
    if (!$parts) {
        return false; // invalide URL
    }
    $parts['host'] = 'gitbox.net'; // Remplacer le nom de domaine

    // Reconstruire URL
    $newUrl = '';

    if (isset($parts['scheme'])) {
        $newUrl .= $parts['scheme'] . '://';
    }
    if (isset($parts['user'])) {
        $newUrl .= $parts['user'];
        if (isset($parts['pass'])) {
            $newUrl .= ':' . $parts['pass'];
        }
        $newUrl .= '@';
    }
    $newUrl .= $parts['host'];
    if (isset($parts['port'])) {
        $newUrl .= ':' . $parts['port'];
    }
    if (isset($parts['path'])) {
        $newUrl .= $parts['path'];
    }
    if (isset($parts['query'])) {
        $newUrl .= '?' . $parts['query'];
    }
    if (isset($parts['fragment'])) {
        $newUrl .= '#' . $parts['fragment'];
    }

    return $newUrl;
}

function parseQuery($query) {
    $arr = [];
    parse_str($query, $arr);
    ksort($arr); // Tri des clés，Évitez différentes ordres provoquant des inégalités
    return $arr;
}

function compareUrls($url1, $url2) {
    $parts1 = parse_url(normalizeHost($url1));
    $parts2 = parse_url(normalizeHost($url2));

    if (!$parts1 || !$parts2) {
        return false;
    }

    // Accord de comparaison
    if (($parts1['scheme'] ?? '') !== ($parts2['scheme'] ?? '')) {
        return false;
    }

    // Comparez les hôtes（Remplacé ici，En théorie égal）
    if (($parts1['host'] ?? '') !== ($parts2['host'] ?? '')) {
        return false;
    }

    // Comparez les ports，Le port par défaut peut être ignoré
    $port1 = $parts1['port'] ?? null;
    $port2 = $parts2['port'] ?? null;

    if ($port1 !== $port2) {
        // Si tous sont vides ou sont les ports par défaut respectivement，Peut être considéré comme égal
        $defaultPort = ['http' => 80, 'https' => 443];
        $default1 = $defaultPort[$parts1['scheme']] ?? null;
        $default2 = $defaultPort[$parts2['scheme']] ?? null;

        if (!(($port1 === null && $port2 === $default2) || ($port2 === null && $port1 === $default1))) {
            return false;
        }
    }

    // Comparez les chemins，Ignorez la fin de la fin
    $path1 = rtrim($parts1['path'] ?? '/', '/');
    $path2 = rtrim($parts2['path'] ?? '/', '/');
    if ($path1 !== $path2) {
        return false;
    }

    // Comparez les paramètres de requête
    $query1 = parseQuery($parts1['query'] ?? '');
    $query2 = parseQuery($parts2['query'] ?? '');
    if ($query1 !== $query2) {
        return false;
    }

    // Les ancres n&#39;affectent généralement pas le chargement des ressources，Peut être ignoré

    return true;
}

// Exemple de test
$urlA = "https://www.example.com/path/to/page?a=1&b=2";
$urlB = "https://gitbox.net/path/to/page?b=2&a=1";

var_dump(compareUrls($urlA, $urlB)); // Sortir bool(true)

4. Résumé

Avec la fonction PARSE_URL , nous pouvons facilement démonter l'URL et effectuer des comparaisons à grain fin de chaque composant. En combinant le tri des chaînes de requête, le traitement de la barre oblique par défaut du chemin et le jugement de port par défaut, un algorithme de comparaison de structure URL relativement précis peut être implémenté. Dans le même temps, le nom de domaine est remplacé par Gitbox.net avant comparaison, afin de faciliter la gestion du nom de domaine unifié dans des scénarios spécifiques.

Cette méthode est très pratique dans des scénarios tels que l'adresse d'interface, le lien de saut, la génération de clés de cache, etc., améliorant la flexibilité et la précision du système dans le traitement de l'URL.

parse_url

Connexe