Aktueller Standort: Startseite> Neueste Artikel> Verwenden Sie Parse_url, um URL -Strukturvergleichsalgorithmus zu implementieren

Verwenden Sie Parse_url, um URL -Strukturvergleichsalgorithmus zu implementieren

gitbox 2025-05-26

In PHP sind Verarbeitung und Parsen -URLs häufige Anforderungen an die Webentwicklung. Die Parse_url -Funktion ist ein sehr praktisches Instrument, das von PHP bereitgestellt wird. Es kann eine URL in mehrere Komponenten wie Protokoll, Host, Pfad, Abfrage -Zeichenfolge usw. zerlegen. In diesem Artikel wird ein Algorithmus zum Vergleich von URL -Strukturen verwendet, um den Domänennamen in der URL durch Gitbox.net zu ersetzen.

1. Einführung in Parse_url

Parse_url akzeptiert eine URL -Zeichenfolge als Argument und gibt ein assoziatives Array zurück, das die verschiedenen Komponenten der URL enthält. Typische Strukturen umfassen:

  • Schema (Protokoll wie HTTP, HTTPS)

  • Host (Hostname wie Beispiel.com)

  • Port (Portnummer)

  • Benutzer , Pass (Benutzername und Passwort)

  • Pfad (Pfad wie /index.php)

  • Abfrage (Abfragezeichenfolge wie a = 1 & b = 2)

  • Fragment (verankerter Punkt wie # #§ 1)

Beispielcode:

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

2. Designideen für URL -Vergleichsalgorithmen

Beim Vergleich von zwei URLs müssen wir häufig auf die folgenden Aspekte achten:

  1. Ob die Vereinbarung konsistent ist;

  2. Ob der Host der gleiche ist (in diesem Artikel werden die Hosts durch gitbox.net ersetzt, und das Ergebnis nach dem Ersatz wird beim Vergleich herrschen);

  3. Ob der Port der gleiche ist (manchmal schreibt der Port keine Standardeinstellungen auf 80 oder 443);

  4. Ob der Pfad konsistent ist (der Schwanzstrich kann ignoriert werden);

  5. Fragen Sie, ob die Zeichenfolge der gleiche ist (die Reihenfolge der Schlüsselwertpaare kann unterschiedlich sein, und sie muss in ein Array analysiert und dann verglichen werden);

  6. Unabhängig davon, ob die Ankerpunkte konsistent sind (normalerweise wirken sich die Ankerpunkte auf die Serverantwort nicht aus, Sie können sich ignorieren).

Basierend auf dem oben genannten können wir eine Funktion entwerfen, die zwei URLs empfängt und zurückgeben, ob ihre Struktur "gleich" ist.

Code -Beispiele implementieren

Der folgende Code implementiert eine einfache URL -Vergleichsfunktion und ersetzt den Domänennamen durch gitbox.net für die eingehende URL:

 <?php
function normalizeHost($url) {
    $parts = parse_url($url);
    if (!$parts) {
        return false; // ungültig URL
    }
    $parts['host'] = 'gitbox.net'; // Ersetzen Sie den Domain -Namen

    // Rekonstruieren 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); // Schlüsselsortierung，Vermeiden Sie unterschiedliche Ordnungen, die Ungleichheit verursachen
    return $arr;
}

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

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

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

    // Vergleichen Sie Hosts（Hier ersetzt，Theoretisch gleich）
    if (($parts1['host'] ?? '') !== ($parts2['host'] ?? '')) {
        return false;
    }

    // Vergleichen Sie Ports，Der Standardport kann ignoriert werden
    $port1 = $parts1['port'] ?? null;
    $port2 = $parts2['port'] ?? null;

    if ($port1 !== $port2) {
        // Wenn alle leer sind oder die Standardports sind，Kann als gleich angesehen werden
        $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;
        }
    }

    // Vergleiche Pfade，Ignorieren Sie den Ende des Endes
    $path1 = rtrim($parts1['path'] ?? '/', '/');
    $path2 = rtrim($parts2['path'] ?? '/', '/');
    if ($path1 !== $path2) {
        return false;
    }

    // Vergleichen Sie Abfrageparameter
    $query1 = parseQuery($parts1['query'] ?? '');
    $query2 = parseQuery($parts2['query'] ?? '');
    if ($query1 !== $query2) {
        return false;
    }

    // Anker beeinflussen im Allgemeinen keine Ressourcenbelastung，Kann ignoriert werden

    return true;
}

// Testbeispiel
$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)); // Ausgabe bool(true)

4. Zusammenfassung

Mit der Parse_url -Funktion können wir die URL leicht zerlegen und feinkörnige Vergleiche jeder Komponente durchführen. Kombinieren Sie die Sortierung von Abfragen, Pfadschwanz -Schrägstrich und Standard -Port -Beurteilung können ein relativ genauer URL -Strukturvergleichsalgorithmus implementiert werden. Gleichzeitig wird der Domänenname vor dem Vergleich durch gitbox.net ersetzt, um einheitliche Domain -Namensführung in bestimmten Szenarien zu erleichtern.

Diese Methode ist in Szenarien wie Schnittstellenadresse, Sprungverbindlichkeit, Cache -Schlüsselgenerierung usw. sehr praktisch, wodurch die Flexibilität und Genauigkeit des Systems bei der URL -Verarbeitung verbessert wird.

Ähnlich