How to use regular expressions in golang to verify whether the URL address is a seventh-level domain name

Using regular expressions to verify whether a URL address is a seventh-level domain name is a very common task in golang. In this article, we will introduce how to use regular expressions in golang to verify whether the URL address is a seventh-level domain name.

First of all, we need to understand what a seventh-level domain name is. In the Internet, a domain name is a string that identifies a set of IP addresses and their corresponding relationships. Among them, the top-level domain name is the highest-level domain name, such as .com, .cn, etc. Below the top-level domain name are the second-level domain names, such as baidu.com, google.cn, etc. Similarly, the seventh-level domain name refers to the seventh-level domain name below the top-level domain name, such as blog.baidu.com, maps.google.cn, etc.

Next, we will use regular expressions in golang to verify whether a URL address is a seventh-level domain name.

First, we need to decompose the URL address into different parts, such as protocol, hostname, path, etc. This can be achieved through the net/url library in golang. The specific code is as follows:

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

After decomposing the host name, we need to perform regular expression verification on the host name. We can use the regular expression library regexp in golang to achieve this. The specific code is as follows:

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 this code, we define a regular expression string sevenLevelDomain, which is used to match the format of the seventh-level domain name. The meaning of this regular expression is: starting with a letter or number, a string of length 1 to 61 composed of letters, numbers and "-", ending with a letter or number, separated by ".", and finally with Domain names ending with letters. This regular expression can match seventh-level domain names such as "blog.baid.com" and "news.sports.cnn.com".

Finally, we just need to combine the above two steps. The specific code is as follows:

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

So far, we have successfully used regular expressions and the net/url library in golang to verify whether the URL address is a seventh-level domain name. Through studying the above code, I believe readers will have a deeper understanding of the use of regular expressions and the processing of URL addresses in golang.

The above is the detailed content of How to use regular expressions in golang to verify whether the URL address is a seventh-level domain name. For more information, please follow other related articles on the PHP Chinese website!