Utilisez des expressions régulières dans Golang pour vérifier si l'entrée est une adresse IPv4 ou IPv6

Ces dernières années, avec la popularité d'Internet et l'expansion des scénarios d'application, de plus en plus de développeurs ont commencé à utiliser le langage GO pour le développement de programmes. Dans le langage GO, il est très courant d'utiliser des expressions régulières pour vérifier si l'entrée est légale. Parmi eux, vérifier si l’entrée est une adresse IPv4 ou IPv6 est l’une des exigences courantes. Cet article explique comment utiliser les expressions régulières dans le langage GO pour vérifier si l'entrée est une adresse IPv4 ou IPv6.

L'adresse IPv4, également connue sous le nom d'adresse Internet Protocol version 4, est un nombre binaire de 32 bits, généralement représenté par quatre nombres décimaux, chaque nombre étant séparé par "." Par exemple, 192.168.0.1 est une adresse IPv4 légale.

L'adresse IPv6, également connue sous le nom d'adresse Internet Protocol version 6, est un nombre binaire de 128 bits, généralement représenté par un groupe de huit nombres hexadécimaux, chaque groupe étant séparé par « : ». Par exemple, 2001:0db8:85a3:0000:0000:8a2e:0370:7334 est une adresse IPv6 légale.

Ci-dessous, nous expliquerons comment utiliser les expressions régulières pour vérifier respectivement les adresses IPv4 et IPv6.

Vérifier l'adresse IPv4

En langage GO, vous pouvez utiliser des expressions régulières pour vérifier si l'adresse IPv4 est légale. L'expression régulière d'une adresse IPv4 est la suivante :

^((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]?)$

Parmi eux, les crochets indiquent des éléments facultatifs, les points d'interrogation indiquent que le nombre d'occurrences d'éléments facultatifs est de 0 ou 1, et les parenthèses indiquent un segment d'adresse complet. L'expression régulière correspond à chaque segment d'adresse un par un de gauche à droite, et chaque segment d'adresse est composé de nombres compris entre 0 et 255. Lorsque tous les segments d'adresse correspondent avec succès, l'expression régulière entière est considérée comme une correspondance réussie, sinon elle est considérée comme un échec de correspondance.

Ensuite, nous utilisons un exemple de code pour montrer comment utiliser des expressions régulières pour vérifier la légitimité d'une adresse IPv4.

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

Résultat de sortie :

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

Comme vous pouvez le voir dans le résultat de sortie, l'adresse IPv4 1 et l'adresse IPv4 2 sont toutes deux des adresses IPv4 légales, tandis que l'adresse IPv4 3 n'est pas une adresse IPv4 légale.

Vérifier l'adresse IPv6

L'expression régulière pour valider les adresses IPv6 est légèrement plus compliquée que la validation des adresses IPv4. L'expression régulière de l'adresse IPv6 est la suivante :

^(([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]))$

Correspond également à chaque segment d'adresse un par un de gauche à droite, mais le format de l'adresse IPv6 est beaucoup plus complexe que celui de l'adresse IPv4. Une adresse IPv6 valide peut être composée de l'une des formes suivantes :

• Huit nombres hexadécimaux de 0 à ffff, séparés par ":" entre chacun deux chiffres
• Huit nombres hexadécimaux de 0 à ffff Le nombre hexadécimal de ffff, séparé par ":" entre tous les deux nombres, mais le dernier nombre peut être omis
• Un ou plusieurs nombres hexadécimaux de 0 à ffff, entre tous les deux nombres Utilisez ":" pour séparer, et "::" peut être utilisé pour représentent des abréviations. Cette abréviation ne peut apparaître qu'une seule fois et ne peut apparaître ni dans le premier ni dans le dernier paragraphe
• Adresse IPv6 spéciale.

Ensuite, nous utilisons également un exemple de code pour montrer comment utiliser des expressions régulières pour vérifier la légalité des adresses IPv6.

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

Résultat de sortie :

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

Comme vous pouvez le voir dans le résultat de sortie, l'adresse IPv6 1 à l'adresse IPv6 8 sont toutes des adresses IPv6 légales.

Résumé

L'utilisation d'expressions régulières dans le langage GO pour vérifier la légalité des adresses IPv4 ou IPv6 peut être obtenue grâce aux expressions régulières. Nous avons introduit les méthodes de vérification des deux adresses ci-dessus et nous espérons que cela sera utile à votre développement. Lorsque vous rencontrez des problèmes similaires, vous pouvez vous référer aux exemples de code et aux expressions régulières de cet article pour implémenter rapidement la vérification.

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!