Verwenden Sie reguläre Ausdrücke in Golang, um zu überprüfen, ob es sich bei der Eingabe um eine IPv4- oder IPv6-Adresse handelt

Mit der Popularität des Internets und der Erweiterung der Anwendungsszenarien haben in den letzten Jahren immer mehr Entwickler begonnen, die GO-Sprache für die Programmentwicklung zu verwenden. In der GO-Sprache ist es eine sehr häufige Anforderung, reguläre Ausdrücke zu verwenden, um zu überprüfen, ob die Eingabe zulässig ist. Unter anderem ist die Überprüfung, ob es sich bei der Eingabe um eine IPv4- oder IPv6-Adresse handelt, eine der häufigsten Anforderungen. In diesem Artikel wird erläutert, wie Sie mithilfe regulärer Ausdrücke in der GO-Sprache überprüfen, ob es sich bei der Eingabe um eine IPv4- oder IPv6-Adresse handelt.

IPv4-Adresse, auch bekannt als Internet Protocol Version 4-Adresse, ist eine 32-Bit-Binärzahl, die normalerweise als vier Dezimalzahlen dargestellt wird, wobei jede Zahl durch „.“ getrennt ist. Beispielsweise ist 192.168.0.1 eine legale IPv4-Adresse.

IPv6-Adresse, auch bekannt als Internet Protocol Version 6-Adresse, ist eine 128-Bit-Binärzahl, die normalerweise als Gruppe von acht Hexadezimalzahlen dargestellt wird, wobei jede Gruppe durch „:“ getrennt ist. Beispielsweise ist 2001:0db8:85a3:0000:0000:8a2e:0370:7334 eine legale IPv6-Adresse.

Im Folgenden stellen wir vor, wie Sie reguläre Ausdrücke verwenden, um IPv4- bzw. IPv6-Adressen zu überprüfen.

IPv4-Adresse überprüfen

In der GO-Sprache können Sie reguläre Ausdrücke verwenden, um zu überprüfen, ob die IPv4-Adresse legal ist. Der reguläre Ausdruck einer IPv4-Adresse lautet wie folgt:

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

Dabei geben eckige Klammern optionale Elemente an, Fragezeichen zeigen an, dass die Anzahl der Vorkommen optionaler Elemente 0 oder 1 beträgt, und Klammern geben ein vollständiges Adresssegment an. Der reguläre Ausdruck gleicht jedes Adresssegment einzeln von links nach rechts ab und jedes Adresssegment besteht aus Zahlen zwischen 0 und 255. Wenn alle Adresssegmente erfolgreich abgeglichen wurden, gilt der gesamte reguläre Ausdruck als erfolgreicher Abgleich; andernfalls gilt der Abgleich als fehlgeschlagen.

Als nächstes demonstrieren wir anhand von Beispielcode, wie man mithilfe regulärer Ausdrücke die Legitimität einer IPv4-Adresse überprüft.

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

Ausgabeergebnis:

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

Wie Sie dem Ausgabeergebnis entnehmen können, sind IPv4-Adresse 1 und IPv4-Adresse 2 beide legale IPv4-Adressen, während IPv4-Adresse 3 keine legale IPv4-Adresse ist.

IPv6-Adresse überprüfen

Der reguläre Ausdruck zur Validierung von IPv6-Adressen ist etwas komplizierter als die Validierung von IPv4-Adressen. Der reguläre Ausdruck der IPv6-Adresse lautet wie folgt:

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

Gleicht auch jedes Adresssegment einzeln von links nach rechts ab, aber das Format der IPv6-Adresse ist viel komplexer als das der IPv4-Adresse. Eine gültige IPv6-Adresse kann aus einer der folgenden Formen bestehen:

• Acht Hexadezimalzahlen von 0 bis ffff, getrennt durch „:“ zwischen jeweils zwei Zahlen;
• Acht Hexadezimalzahlen von 0 bis ffff Die Hexadezimalzahl von ffff, getrennt durch „:“ zwischen jeweils zwei Zahlen, aber die letzte Zahl kann weggelassen werden; stellen Abkürzungen dar. Diese Abkürzung darf nur einmal vorkommen und darf nicht im ersten oder letzten Absatz vorkommen.
• Spezielle IPv6-Adresse.
• Als nächstes verwenden wir auch Beispielcode, um zu demonstrieren, wie man reguläre Ausdrücke verwendet, um die Rechtmäßigkeit von IPv6-Adressen zu überprüfen.

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

Ausgabeergebnis:

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

Wie Sie dem Ausgabeergebnis entnehmen können, sind IPv6-Adresse 1 bis IPv6-Adresse 8 allesamt legale IPv6-Adressen.

Zusammenfassung

Die Verwendung regulärer Ausdrücke in der GO-Sprache zur Überprüfung der Rechtmäßigkeit von IPv4- oder IPv6-Adressen kann durch reguläre Ausdrücke erreicht werden. Wir haben die Verifizierungsmethoden der beiden oben genannten Adressen eingeführt und hoffen, dass sie für Ihre Entwicklung hilfreich sein werden. Wenn Sie auf ähnliche Probleme stoßen, können Sie auf die Codebeispiele und regulären Ausdrücke in diesem Artikel zurückgreifen, um die Überprüfung schnell umzusetzen.

Das obige ist der detaillierte Inhalt vonVerwenden Sie reguläre Ausdrücke in Golang, um zu überprüfen, ob es sich bei der Eingabe um eine IPv4- oder IPv6-Adresse handelt. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!