IP Address Regex Go Validator

Einführung: Was ist ein IP-Adressen-Regex?

In Go bieten reguläre Ausdrücke (regex) eine leistungsstarke Möglichkeit, Muster wie IP-Adressen zu validieren. IP-Adressen sind in jedem netzwerkbasierten System grundlegend, ob Sie Nutzerinformationen speichern, Firewalls konfigurieren oder Web-Anwendungen entwickeln.

IP-Adressen gibt es in zwei Varianten:

• IPv4 (z. B. 192.168.1.1)

• IPv6 (z. B. 2001:0db8:85a3:0000:0000:8a2e:0370:7334)

IP-Adressen-Regex-Muster

IPv4-Regex-Muster

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

Unterstützte Regex-Varianten

Diese IPv4-Regex-Muster funktionieren in einer Vielzahl moderner Regex-Engines, einschließlich Go, Python, JavaScript, .NET, Java, Perl, Ruby und PCRE. Ob Sie die Validierung in Backend-Code, Skripte oder APIs integrieren: Sie können davon ausgehen, dass diese Ausdrücke in den meisten gängigen Entwicklungsumgebungen konsistent funktionieren.

Erläuterung:

• Validiert 4 durch Punkte getrennte Oktette.

• Jedes Oktett liegt im Bereich von 0 bis 255.

• Beispiel-Treffer: 192.168.0.1

Zusätzliche Hinweise zur IPv4-Validierung

Einfachere Muster wie ^([0-9]{1,3}).([0-9]{1,3}).([0-9]{1,3}).([0-9]{1,3})$ stimmen mit vier beliebigen Gruppen aus 1 bis 3 Ziffern überein, schränken den Bereich pro Oktett jedoch nicht auf 0 bis 255 ein. Das oben gezeigte Muster ist präziser und wird von .NET, Java, JavaScript, PCRE, Perl, Python und Ruby unterstützt.

Einfache vs. präzise IPv4-Regex-Muster

Einfaches IPv4-Regex:
Ein einfaches Muster wie ^(?:[0-9]{1,3}\.){3}[0-9]{1,3}$ prüft nur die Struktur, erlaubt aber auch ungültige Adressen wie 999.999.999.999.

Präzises IPv4-Regex:
Ein genaueres Muster stellt sicher, dass jedes Oktett zwischen 0 und 255 liegt. Es lehnt Eingaben wie 300.1.1.1 oder 256.256.256.256 korrekt ab.

• Einfaches Regex: Schnell, lässt aber ungültige Adressen durch.

• Präzises Regex: Etwas komplexer, garantiert aber echte IPv4-Gültigkeit.

IPv4-Adressen mit Regex aus Text extrahieren

Müssen Sie IPv4-Adressen aus rohen Logs oder Textblöcken extrahieren? Regex macht diese Aufgabe einfach und effizient.

Einfaches Extraktionsmuster

\b(?:[0-9]{1,3}\.){3}[0-9]{1,3}\b

Strengeres Muster für echte Adressen

\b(?:(?:25[0-5]2[0-4][0-9]1\d\d[1-9]?\d)\.){3}
   (?:25[0-5]2[0-4][0-9]1\d\d[1-9]?\d)\b

Beispiel:
Aus Log: Failed attempt from 192.168.99.120 at noon extrahiert das strengere Muster 192.168.99.120.

IPv6-Regex-Muster

^([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$

Erläuterung:

• Stimmt mit 8 durch Doppelpunkte getrennten Gruppen hexadezimaler Zahlen überein.

• Jede Gruppe hat 1 bis 4 Hex-Ziffern.

• Beispiel-Treffer: 2001:0db8:85a3:0000:0000:8a2e:0370:7334

IP-Adressen in Go mit Regex validieren

Verwenden Sie das in Go eingebaute regexp-Paket, um das Muster zu kompilieren und Strings zu testen:

package main
import (
"fmt"
"regexp"
)
func isValidIPv4(ip string) bool {
ipv4Pattern := ^(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}$
regex := regexp.MustCompile(ipv4Pattern)
return regex.MatchString(ip)
}
func isValidIPv6(ip string) bool {
ipv6Pattern := ^([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$
regex := regexp.MustCompile(ipv6Pattern)
return regex.MatchString(ip)
}
func main() {
testIPs := []string{
"192.168.1.1",                    // valid IPv4
"256.300.88.1",                   // invalid IPv4
"2001:0db8:85a3:0000:0000:8a2e:0370:7334", // valid IPv6
"2001:db8::1",                    // invalid (compressed, unsupported here)
}
for _, ip := range testIPs {
    fmt.Printf("IP: %s | IPv4: %t | IPv6: %t\n", ip, isValidIPv4(ip), isValidIPv6(ip))
}

}

Optional: IPv4-Adresse in einen 32-Bit-Integer umwandeln

Nach der Validierung können Sie eine IPv4-Adresse in einen 32-Bit-Integer umwandeln, etwa für die effiziente Speicherung oder für Vergleiche mit Low-Level-Networking-APIs.

import (
"fmt"
"strconv"
"strings"
)
func ipv4ToInt(ip string) (uint32, error) {
octets := strings.Split(ip, ".")
if len(octets) != 4 {
return 0, fmt.Errorf("invalid IPv4 address")
}
var result uint32
for i := 0; i < 4; i++ {
octet, err := strconv.Atoi(octets[i])
if err != nil octet < 0 octet > 255 {
return 0, fmt.Errorf("invalid octet in IPv4 address")
}
result = (result << 8) uint32(octet)
}
return result, nil
}

Anwendungsfälle der IP-Adressen-Regex-Validierung

• Nutzer-IP-Tracking: IPs vor der Speicherung in Logs oder Analyse-Tools validieren.

• Zugriffskontrolle: Nur Anfragen aus erlaubten IP-Bereichen zulassen.

• Netzwerkkonfiguration: Validierung von IPs bei der Einrichtung oder Provisionierung automatisieren.

• Datenbereinigung: Datensätze mit fehlerhaften IP-Einträgen standardisieren.

Profi-Tipps

• IPv6-Validierung nur bei Bedarf einsetzen, da viele Systeme primär auf IPv4 setzen.

• Regex validiert keine reservierten oder lokalen IPs (wie 127.0.0.1 oder ::1), sondern nur das Format.

• Für komprimierte IPv6-Formate (wie ::1) sollte das net-Paket für vollständiges Parsen verwendet werden.

• Verwenden Sie den Go Regex Tester, um Ihre IP-Muster zu verfeinern und Grenzfälle zu testen.

Kombinieren Sie dieses Tool mit

• Password Regex Go Validator für sichere Benutzeranmeldedaten

• Email Regex Go Validator für die Validierung von Kontaktdaten

• URL Regex Go Validator für die Validierung von IP-gebundenen URLs

• Go Regex Tester zum direkten Testen Ihrer IP-Muster

• GUID Regex Go Validator für die Validierung von Ressourcenkennungen