Use regular expressions in golang to verify whether the input is an IPv4 or IPv6 address-Golang-php.cn

In recent years, with the popularity of the Internet and the expansion of application scenarios, more and more developers have begun to use GO language for program development. In the GO language, it is a very common requirement to use regular expressions to verify whether the input is legal. Among them, verifying whether the input is an IPv4 or IPv6 address is one of the common requirements. This article will introduce how to use regular expressions in GO language to verify whether the input is an IPv4 or IPv6 address.

IPv4 address, also known as Internet Protocol version 4 address, is a 32-bit binary number, usually represented as four decimal numbers, each number separated by "." For example, 192.168.0.1 is a legal IPv4 address.

IPv6 address, also known as Internet Protocol version 6 address, is a 128-bit binary number, usually represented as a group of eight hexadecimal numbers, with ":" between each group. separate. For example, 2001:0db8:85a3:0000:0000:8a2e:0370:7334 is a legal IPv6 address.

Below, we will introduce how to use regular expressions to verify IPv4 and IPv6 addresses respectively.

Verify IPv4 address

In GO language, you can use regular expressions to verify whether the IPv4 address is legal. The regular expression of an IPv4 address is as follows:

^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?).){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$

Copy after login

Among them, square brackets indicate optional items, question marks indicate that the number of occurrences of optional items is 0 or 1, and parentheses indicate a complete address segment. The regular expression matches each address segment one by one from left to right, and each address segment is composed of numbers between 0 and 255. When all address segments are matched successfully, the entire regular expression is considered a successful match, otherwise it is considered a match failure.

Next, we use sample code to demonstrate how to use regular expressions to verify the legitimacy of an IPv4 address.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    ipv4Regex := `^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?).){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$`

    ipv4Address1 := "192.0.2.1"
    ipv4Address2 := "255.255.255.255"
    ipv4Address3 := "256.0.0.1"

    match1, _ := regexp.MatchString(ipv4Regex, ipv4Address1)
    match2, _ := regexp.MatchString(ipv4Regex, ipv4Address2)
    match3, _ := regexp.MatchString(ipv4Regex, ipv4Address3)

    fmt.Println("IPv4 address 1 is valid: ", match1)
    fmt.Println("IPv4 address 2 is valid: ", match2)
    fmt.Println("IPv4 address 3 is valid: ", match3)
}

Copy after login

Output result:

IPv4 address 1 is valid: true
IPv4 address 2 is valid: true
IPv4 address 3 is valid: false

Copy after login

As you can see from the output result, IPv4 address 1 and IPv4 address 2 are both legal IPv4 addresses, while IPv4 address 3 is not a legal IPv4 address.

Verify IPv6 address

Compared with verifying IPv4 address, the regular expression for verifying IPv6 address is slightly more complicated. The regular expression of IPv6 address is as follows:

^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:([0-9a-fA-F]{1,4}|:)|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]).){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]).){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))$

Copy after login

also matches each address segment one by one from left to right, but the format of IPv6 address is much more complicated than IPv4 address. A valid IPv6 address can be composed of one of the following forms:

Eight hexadecimal numbers from 0 to ffff, separated by ":" between each two numbers;
Eight hexadecimal numbers from 0 to ffff, each two numbers are separated by ":", but the last number can be omitted;
One or more numbers from 0 to The hexadecimal number of ffff is separated by ":" between each two numbers, and "::" can be used to represent the abbreviation. This abbreviation can only appear once and cannot appear in the first or last paragraph;
Special IPv6 address.

Next, we also use sample code to demonstrate how to use regular expressions to verify the legality of IPv6 addresses.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    ipv6Regex := `^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:([0-9a-fA-F]{1,4}|:)|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]).){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]).){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))$`

    ipv6Address1 := "2001:0db8:85a3:0000:0000:8a2e:0370:7334"
    ipv6Address2 := "2001:db8::1"
    ipv6Address3 := "2001:db8:::1"
    ipv6Address4 := "ff02::2"
    ipv6Address5 := "fe80::1%eth0"
    ipv6Address6 := "fe80::1234:5678:9abc:def0%3"
    ipv6Address7 := "::ffff:192.0.2.128"
    ipv6Address8 := "0:0:0:0:0:0:0:1"

    match1, _ := regexp.MatchString(ipv6Regex, ipv6Address1)
    match2, _ := regexp.MatchString(ipv6Regex, ipv6Address2)
    match3, _ := regexp.MatchString(ipv6Regex, ipv6Address3)
    match4, _ := regexp.MatchString(ipv6Regex, ipv6Address4)
    match5, _ := regexp.MatchString(ipv6Regex, ipv6Address5)
    match6, _ := regexp.MatchString(ipv6Regex, ipv6Address6)
    match7, _ := regexp.MatchString(ipv6Regex, ipv6Address7)
    match8, _ := regexp.MatchString(ipv6Regex, ipv6Address8)

    fmt.Println("IPv6 address 1 is valid: ", match1)
    fmt.Println("IPv6 address 2 is valid: ", match2)
    fmt.Println("IPv6 address 3 is valid: ", match3)
    fmt.Println("IPv6 address 4 is valid: ", match4)
    fmt.Println("IPv6 address 5 is valid: ", match5)
    fmt.Println("IPv6 address 6 is valid: ", match6)
    fmt.Println("IPv6 address 7 is valid: ", match7)
    fmt.Println("IPv6 address 8 is valid: ", match8)
}

Copy after login

Output result:

IPv6 address 1 is valid: true
IPv6 address 2 is valid: true
IPv6 address 3 is valid: false
IPv6 address 4 is valid: true
IPv6 address 5 is valid: true
IPv6 address 6 is valid: true
IPv6 address 7 is valid: true
IPv6 address 8 is valid: true

Copy after login

As you can see from the output result, IPv6 address 1 to IPv6 address 8 are all legal IPv6 addresses.

Summary

Using regular expressions in GO language to verify the legality of IPv4 or IPv6 addresses can be achieved through regular expressions. We have introduced the verification methods of the above two addresses, and we hope it will be helpful to your development. When encountering similar problems, you can refer to the code examples and regular expressions in this article to quickly implement verification.

The above is the detailed content of Use regular expressions in golang to verify whether the input is an IPv4 or IPv6 address. For more information, please follow other related articles on the PHP Chinese website!