So verwenden Sie reguläre Ausdrücke in Golang, um zu überprüfen, ob es sich bei der URL-Adresse um einen Domänennamen der siebten Ebene handelt

Die Verwendung regulärer Ausdrücke zur Überprüfung, ob eine URL-Adresse ein Domänenname der siebten Ebene ist, ist eine sehr häufige Aufgabe in Golang. In diesem Artikel stellen wir vor, wie man reguläre Ausdrücke in Golang verwendet, um zu überprüfen, ob es sich bei der URL-Adresse um einen Domänennamen der siebten Ebene handelt.

Zunächst müssen wir verstehen, was ein Domainname der siebten Ebene ist. Im Internet ist ein Domänenname eine Zeichenfolge, die eine Gruppe von IP-Adressen und ihre entsprechenden Beziehungen identifiziert. Unter diesen ist der Domänenname der obersten Ebene der Domänenname der höchsten Ebene, z. B. .com, .cn usw. Unterhalb des Top-Level-Domain-Namens befinden sich die Second-Level-Domain-Namen wie baidu.com, google.cn usw. In ähnlicher Weise bezieht sich der Domänenname der siebten Ebene auf den Domänennamen der siebten Ebene unterhalb des Domänennamens der obersten Ebene, z. B. blog.baidu.com, maps.google.cn usw.

Als nächstes verwenden wir reguläre Ausdrücke in Golang, um zu überprüfen, ob es sich bei einer URL-Adresse um einen Domänennamen der siebten Ebene handelt.

Zuerst müssen wir die URL-Adresse in verschiedene Teile zerlegen, wie Protokoll, Hostname, Pfad usw. Dies kann über die Net/URL-Bibliothek in Golang erreicht werden. Der spezifische Code lautet wie folgt:

import (
    "fmt"
    "net/url"
)

func main() {
    rawurl := "https://blog.baid.com/path/to/resource"
    parsedUrl, err := url.Parse(rawurl)
    if err != nil {
        fmt.Printf("Parsing URL failed: %s
", err.Error())
        return
    }

    fmt.Println(parsedUrl.Scheme)     // 输出 "https"
    fmt.Println(parsedUrl.Hostname()) // 输出 "blog.baid.com"
    fmt.Println(parsedUrl.Path)       // 输出 "/path/to/resource"
}

Nach der Zerlegung des Hostnamens müssen wir eine Überprüfung des regulären Ausdrucks für den Hostnamen durchführen. Um dies zu erreichen, können wir die reguläre Ausdrucksbibliothek regexp in Golang verwenden. Der spezifische Code lautet wie folgt:

import (
    "fmt"
    "regexp"
)

func main() {
    hostname := "blog.baid.com" // 从上一步获取
    sevenLevelDomain := `^([a-zA-Z0-9][-a-zA-Z0-9]{0,61}[a-zA-Z0-9].)+([a-zA-Z]{2,})$`

    matched, err := regexp.MatchString(sevenLevelDomain, hostname)
    if err != nil {
        fmt.Printf("Regex validation failed: %s
", err.Error())
        return
    }

    if matched {
        fmt.Println("This is a valid seven-level domain.")
    } else {
        fmt.Println("This is NOT a valid seven-level domain.")
    }
}

In diesem Code definieren wir eine reguläre Ausdruckszeichenfolge sevenLevelDomain, die verwendet wird, um das Format des Domänennamens der siebten Ebene abzugleichen. Die Bedeutung dieses regulären Ausdrucks ist: beginnend mit einem Buchstaben oder einer Zahl, eine Zeichenfolge mit einer Länge von 1 bis 61, bestehend aus Buchstaben, Zahlen und „-“, endend mit einem Buchstaben oder einer Zahl, getrennt durch „.“ und schließlich mit Domänennamen mit Buchstaben enden. Dieser reguläre Ausdruck kann mit Domänennamen der siebten Ebene wie „blog.baid.com“ und „news.sports.cnn.com“ übereinstimmen.

Abschließend müssen wir nur noch die beiden oben genannten Schritte kombinieren. Der spezifische Code lautet wie folgt:

import (
    "fmt"
    "net/url"
    "regexp"
)

func main() {
    rawurl := "https://blog.baid.com/path/to/resource"

    parsedUrl, err := url.Parse(rawurl)
    if err != nil {
        fmt.Printf("Parsing URL failed: %s
", err.Error())
        return
    }

    sevenLevelDomain := `^([a-zA-Z0-9][-a-zA-Z0-9]{0,61}[a-zA-Z0-9].)+([a-zA-Z]{2,})$`
    matched, err := regexp.MatchString(sevenLevelDomain, parsedUrl.Hostname())
    if err != nil {
        fmt.Printf("Regex validation failed: %s
", err.Error())
        return
    }

    if matched {
        fmt.Printf("%s is a valid seven-level domain.
", parsedUrl.Hostname())
    } else {
        fmt.Printf("%s is NOT a valid seven-level domain.
", parsedUrl.Hostname())
    }
}

Bisher haben wir erfolgreich reguläre Ausdrücke und die net/url-Bibliothek in Golang verwendet, um zu überprüfen, ob es sich bei der URL-Adresse um einen Domänennamen der siebten Ebene handelt. Ich glaube, dass die Leser durch das Studium des obigen Codes ein tieferes Verständnis für die Verwendung regulärer Ausdrücke und die Verarbeitung von URL-Adressen in Golang erlangen werden.

Das obige ist der detaillierte Inhalt vonSo verwenden Sie reguläre Ausdrücke in Golang, um zu überprüfen, ob es sich bei der URL-Adresse um einen Domänennamen der siebten Ebene handelt. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!