Comment utiliser des expressions régulières dans Golang pour vérifier si l'adresse URL est un nom de domaine de septième niveau

Utiliser des expressions régulières pour vérifier si une adresse URL est un nom de domaine de septième niveau est une tâche très courante dans Golang. Dans cet article, nous expliquerons comment utiliser les expressions régulières dans Golang pour vérifier si l'adresse URL est un nom de domaine de septième niveau.

Tout d'abord, nous devons comprendre ce qu'est un nom de domaine de septième niveau. Sur Internet, un nom de domaine est une chaîne qui identifie un ensemble d'adresses IP et leurs relations correspondantes. Parmi eux, le nom de domaine de premier niveau est le nom de domaine de plus haut niveau, tel que .com, .cn, etc. Sous le nom de domaine de premier niveau se trouvent les noms de domaine de deuxième niveau, tels que baidu.com, google.cn, etc. De même, le nom de domaine de septième niveau fait référence au nom de domaine de septième niveau situé sous le nom de domaine de premier niveau, tel que blog.baidu.com, maps.google.cn, etc.

Ensuite, nous utiliserons des expressions régulières en golang pour vérifier si une adresse URL est un nom de domaine de septième niveau.

Tout d'abord, nous devons décomposer l'adresse URL en différentes parties, telles que le protocole, le nom d'hôte, le chemin, etc. Ceci peut être réalisé via la bibliothèque net/url de Golang. Le code spécifique est le suivant :

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"
}

Après avoir décomposé le nom d'hôte, nous devons effectuer une vérification d'expression régulière sur le nom d'hôte. Nous pouvons utiliser l'expression rationnelle de la bibliothèque d'expressions régulières dans Golang pour y parvenir. Le code spécifique est le suivant :

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.")
    }
}

Dans ce code, nous définissons une chaîne d'expression régulière sevenLevelDomain, qui est utilisée pour correspondre au format du nom de domaine de septième niveau. La signification de cette expression régulière est la suivante : commençant par une lettre ou un chiffre, une chaîne de longueur de 1 à 61 composée de lettres, de chiffres et de "-", se terminant par une lettre ou un chiffre, séparés par ".", et enfin par Noms de domaine se terminant par des lettres. Cette expression régulière peut correspondre à des noms de domaine de septième niveau tels que « blog.baid.com » et « news.sports.cnn.com ».

Enfin, il suffit de combiner les deux étapes ci-dessus. Le code spécifique est le suivant :

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())
    }
}

Jusqu'à présent, nous avons utilisé avec succès des expressions régulières et la bibliothèque net/url de golang pour vérifier si l'adresse URL est un nom de domaine de septième niveau. En étudiant le code ci-dessus, je pense que les lecteurs comprendront mieux l'utilisation des expressions régulières et le traitement des adresses URL dans Golang.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!