Home > Article > Backend Development > Use regular expressions in golang to verify whether the input is an IPv4 or IPv6 address
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]?)$
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) }
Output result:
IPv4 address 1 is valid: true IPv4 address 2 is valid: true IPv4 address 3 is valid: false
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]))$
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:
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) }
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
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!