


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:
- 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) }
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!

Gooffersrobustfeaturesforsecurecoding,butdevelopersmustimplementsecuritybestpracticeseffectively.1)UseGo'scryptopackageforsecuredatahandling.2)Manageconcurrencywithsynchronizationprimitivestopreventraceconditions.3)SanitizeexternalinputstoavoidSQLinj

Go's error interface is defined as typeerrorinterface{Error()string}, allowing any type that implements the Error() method to be considered an error. The steps for use are as follows: 1. Basically check and log errors, such as iferr!=nil{log.Printf("Anerroroccurred:%v",err)return}. 2. Create a custom error type to provide more information, such as typeMyErrorstruct{MsgstringDetailstring}. 3. Use error wrappers (since Go1.13) to add context without losing the original error message,

ToeffectivelyhandleerrorsinconcurrentGoprograms,usechannelstocommunicateerrors,implementerrorwatchers,considertimeouts,usebufferedchannels,andprovideclearerrormessages.1)Usechannelstopasserrorsfromgoroutinestothemainfunction.2)Implementanerrorwatcher

In Go language, the implementation of the interface is performed implicitly. 1) Implicit implementation: As long as the type contains all methods defined by the interface, the interface will be automatically satisfied. 2) Empty interface: All types of interface{} types are implemented, and moderate use can avoid type safety problems. 3) Interface isolation: Design a small but focused interface to improve the maintainability and reusability of the code. 4) Test: The interface helps to unit test by mocking dependencies. 5) Error handling: The error can be handled uniformly through the interface.

Go'sinterfacesareimplicitlyimplemented,unlikeJavaandC#whichrequireexplicitimplementation.1)InGo,anytypewiththerequiredmethodsautomaticallyimplementsaninterface,promotingsimplicityandflexibility.2)JavaandC#demandexplicitinterfacedeclarations,offeringc

Toensureinitfunctionsareeffectiveandmaintainable:1)Minimizesideeffectsbyreturningvaluesinsteadofmodifyingglobalstate,2)Ensureidempotencytohandlemultiplecallssafely,and3)Breakdowncomplexinitializationintosmaller,focusedfunctionstoenhancemodularityandm

Goisidealforbeginnersandsuitableforcloudandnetworkservicesduetoitssimplicity,efficiency,andconcurrencyfeatures.1)InstallGofromtheofficialwebsiteandverifywith'goversion'.2)Createandrunyourfirstprogramwith'gorunhello.go'.3)Exploreconcurrencyusinggorout

Developers should follow the following best practices: 1. Carefully manage goroutines to prevent resource leakage; 2. Use channels for synchronization, but avoid overuse; 3. Explicitly handle errors in concurrent programs; 4. Understand GOMAXPROCS to optimize performance. These practices are crucial for efficient and robust software development because they ensure effective management of resources, proper synchronization implementation, proper error handling, and performance optimization, thereby improving software efficiency and maintainability.


Hot AI Tools

Undresser.AI Undress
AI-powered app for creating realistic nude photos

AI Clothes Remover
Online AI tool for removing clothes from photos.

Undress AI Tool
Undress images for free

Clothoff.io
AI clothes remover

Video Face Swap
Swap faces in any video effortlessly with our completely free AI face swap tool!

Hot Article

Hot Tools

PhpStorm Mac version
The latest (2018.2.1) professional PHP integrated development tool

mPDF
mPDF is a PHP library that can generate PDF files from UTF-8 encoded HTML. The original author, Ian Back, wrote mPDF to output PDF files "on the fly" from his website and handle different languages. It is slower than original scripts like HTML2FPDF and produces larger files when using Unicode fonts, but supports CSS styles etc. and has a lot of enhancements. Supports almost all languages, including RTL (Arabic and Hebrew) and CJK (Chinese, Japanese and Korean). Supports nested block-level elements (such as P, DIV),

MinGW - Minimalist GNU for Windows
This project is in the process of being migrated to osdn.net/projects/mingw, you can continue to follow us there. MinGW: A native Windows port of the GNU Compiler Collection (GCC), freely distributable import libraries and header files for building native Windows applications; includes extensions to the MSVC runtime to support C99 functionality. All MinGW software can run on 64-bit Windows platforms.

MantisBT
Mantis is an easy-to-deploy web-based defect tracking tool designed to aid in product defect tracking. It requires PHP, MySQL and a web server. Check out our demo and hosting services.

EditPlus Chinese cracked version
Small size, syntax highlighting, does not support code prompt function
