Regulären Ausdruck entspricht, gültige IPv6-Adressen

Ich habe Probleme beim schreiben eines regulären Ausdrucks übereinstimmt gültige IPv6-Adressen, einschließlich derjenigen, die in Ihrer komprimierten form (mit :: oder führenden Nullen ausgelassen werden aus jedem byte-pair-Mädchen).

Kann jemand empfehlen, einen regulären Ausdruck, erfüllen die Anforderung?

Ich bin angesichts des expandierenden jedes byte-pair-matching und das Ergebnis mit einfacher regex.

Check out intermapper.com/ipv6validator.. es links zu dieser perl-test-script
Ich habe versucht all die Antworten und arbeiten Sie nicht für alle meine Testfälle und/oder Sie beinhalten auch eine IPv4, das war nicht gefragt. Ich habe festgestellt, dass dies die sauberste Lösung so weit: stackoverflow.com/a/21944928/3112803

InformationsquelleAutor Readonly | 2008-09-10

221

War ich nicht in der Lage zu bekommen @Faktor Mystische Antwort auf das arbeiten mit der POSIX regulären Ausdrücke, also schrieb ich ein, dass die arbeiten mit POSIX reguläre Ausdrücke und reguläre PERL-Ausdrücke.

Sollte es passen:

IPv6-Adressen
null komprimierte IPv6-Adressen (Abschnitt 2.2 rfc5952)
link-lokale IPv6-Adressen mit zone index (§ 11 rfc4007)
IPv4 Eingebettete IPv6-Adresse (Abschnitt 2 rfc6052)
IPv4-mapped-IPv6-Adressen (Abschnitt 2.1 rfc2765)
IPv4-Adressen übersetzt (Abschnitt 2.1 rfc2765)

IPv6 Regulären Ausdruck:

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

Lesen zu erleichtern, werden die folgenden der oben genannten regulären Ausdruck split bei den großen, ODER Punkte, die in separaten Zeilen:

# IPv6 RegEx
(
([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|          # 1:2:3:4:5:6:7:8
([0-9a-fA-F]{1,4}:){1,7}:|                         # 1::                              1:2:3:4:5:6:7::
([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|         # 1::8             1:2:3:4:5:6::8  1:2:3:4:5:6::8
([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|  # 1::7:8           1:2:3:4:5::7:8  1:2:3:4:5::8
([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|  # 1::6:7:8         1:2:3:4::6:7:8  1:2:3:4::8
([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|  # 1::5:6:7:8       1:2:3::5:6:7:8  1:2:3::8
([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|  # 1::4:5:6:7:8     1:2::4:5:6:7:8  1:2::8
[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|       # 1::3:4:5:6:7:8   1::3:4:5:6:7:8  1::8  
:((:[0-9a-fA-F]{1,4}){1,7}|:)|                     # ::2:3:4:5:6:7:8  ::2:3:4:5:6:7:8 ::8       ::     
fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|     # fe80::7:8%eth0   fe80::7:8%1     (link-local IPv6 addresses with zone index)
::(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])|          # ::255.255.255.255   ::ffff:255.255.255.255  ::ffff:0:255.255.255.255  (IPv4-mapped IPv6 addresses and IPv4-translated addresses)
([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])           # 2001:db8:3:4::192.0.2.33  64:ff9b::192.0.2.33 (IPv4-Embedded IPv6 Address)
)

# IPv4 RegEx
((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])

Machen die oben leichter zu verstehen, werden die folgenden "pseudo-code", wird die oben:

IPV4SEG  = (25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])
IPV4ADDR = (IPV4SEG\.){3,3}IPV4SEG
IPV6SEG  = [0-9a-fA-F]{1,4}
IPV6ADDR = (
           (IPV6SEG:){7,7}IPV6SEG|                # 1:2:3:4:5:6:7:8
           (IPV6SEG:){1,7}:|                      # 1::                                 1:2:3:4:5:6:7::
           (IPV6SEG:){1,6}:IPV6SEG|               # 1::8               1:2:3:4:5:6::8   1:2:3:4:5:6::8
           (IPV6SEG:){1,5}(:IPV6SEG){1,2}|        # 1::7:8             1:2:3:4:5::7:8   1:2:3:4:5::8
           (IPV6SEG:){1,4}(:IPV6SEG){1,3}|        # 1::6:7:8           1:2:3:4::6:7:8   1:2:3:4::8
           (IPV6SEG:){1,3}(:IPV6SEG){1,4}|        # 1::5:6:7:8         1:2:3::5:6:7:8   1:2:3::8
           (IPV6SEG:){1,2}(:IPV6SEG){1,5}|        # 1::4:5:6:7:8       1:2::4:5:6:7:8   1:2::8
           IPV6SEG:((:IPV6SEG){1,6})|             # 1::3:4:5:6:7:8     1::3:4:5:6:7:8   1::8
           :((:IPV6SEG){1,7}|:)|                  # ::2:3:4:5:6:7:8    ::2:3:4:5:6:7:8  ::8       ::       
           fe80:(:IPV6SEG){0,4}%[0-9a-zA-Z]{1,}|  # fe80::7:8%eth0     fe80::7:8%1  (link-local IPv6 addresses with zone index)
           ::(ffff(:0{1,4}){0,1}:){0,1}IPV4ADDR|  # ::255.255.255.255  ::ffff:255.255.255.255  ::ffff:0:255.255.255.255 (IPv4-mapped IPv6 addresses and IPv4-translated addresses)
           (IPV6SEG:){1,4}:IPV4ADDR               # 2001:db8:3:4::192.0.2.33  64:ff9b::192.0.2.33 (IPv4-Embedded IPv6 Address)
           )

Ich geschrieben ein Skript auf GitHub, die tests mit dem regulären Ausdruck: https://gist.github.com/syzdek/6086792

Sie IPv4-regex nicht mit IPs wie 127.000.000.001
IPv4-Segmente sollte nicht führende Nullen enthalten. Wenn eine führende null vorhanden ist, wird die IPv4-segment interpretiert werden sollten in oktal. Also die IPV4SEG oben ist korrekt in nicht erlaubt '000'. Es hat jedoch gestatten, '00', was es nicht sein sollte.
Hat bei mir nicht funktioniert, im browser, wie ich es erwarten würde. Validiert, auch reg.test('3zzzzffe:1900:4545:3:200:f8ff:fe21:67cf"), die offensichtlich nicht um eine gültige IPv6-Adresse. Hatte viel bessere Ergebnisse mit regex hier: nbviewer.ipython.org/github/rasbt/python_reference/blob/master/...
fantastische ipv6-regex. einen kleinen Fehler mit der link-local-Bereich. Sie hatte fe80 wo es sollte so etwas wie [fF][eE]80 und ein ffff denen sollte so etwas wie [fF]{4}
+1 für die zeigen, dass regexes werden kann (in der gleichen Weise wie jeder source-code) tatsächlich lesbar sind, wenn Sie nehmen Sie die Pflege und formatieren Sie Sie.

InformationsquelleAutor David M. Syzdek

49

Den folgenden überprüft, ob Sie IPv4 -, IPv6 - (voll-und komprimiert) und IPv6v4 (voll-und komprimierte) Adressen:
```
'/^(?>(?>([a-f0-9]{1,4})(?>:(?1)){7}|(?!(?:.*[a-f0-9](?>:|$)){8,})((?1)(?>:(?1)){0,6})?::(?2)?)|(?>(?>(?1)(?>:(?1)){5}:|(?!(?:.*[a-f0-9]:){6,})(?3)?::(?>((?1)(?>:(?1)){0,4}):)?)?(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])(?>\.(?4)){3}))$/iD'
```
Obwohl die Validierung von ip-s könnte getan werden, wie Frank Krüger schlägt vor, diese Lösung ist die eine, die tatsächlich Antworten auf die Frage (auch wenn ich noch nicht vollständig getestet ist es noch), sowie wenn Sie haben viele IP-s, die Sie möchten syntaktisch testen und vielleicht passen in eine Zeile text, die Sie nicht verwenden können IP-validation-Technik.
Hi, getestet habe ich diese RegExp und nicht für mich gearbeitet. Es sagt D ist ein ungültiges flag verwendet wird, und wenn ich es entfernen er sagt: "SyntaxError: invalid Quantifizierer"
JavaScript implementiert ein subset von Perl-Stil reguläre Ausdrücke, nicht die Gesamtheit von PCRE. Mein regex funktioniert nicht, ohne einige der erweiterten Funktionen von PCRE.
Dies gibt Ausnahme für mich in C#
Fehlerhaften Testfall: FE80:0000:0000:0000:0202:B3FF:FE1E:8329 unter Verwendung der neuesten version von Elixir auf das Datum, das verwendet PCRE darunter.

InformationsquelleAutor

Vom "IPv6-regex":

(\A([0-9a-f]{1,4}:){1,1}(:[0-9a-f]{1,4}){1,6}\Z)|
(\A([0-9a-f]{1,4}:){1,2}(:[0-9a-f]{1,4}){1,5}\Z)|
(\A([0-9a-f]{1,4}:){1,3}(:[0-9a-f]{1,4}){1,4}\Z)|
(\A([0-9a-f]{1,4}:){1,4}(:[0-9a-f]{1,4}){1,3}\Z)|
(\A([0-9a-f]{1,4}:){1,5}(:[0-9a-f]{1,4}){1,2}\Z)|
(\A([0-9a-f]{1,4}:){1,6}(:[0-9a-f]{1,4}){1,1}\Z)|
(\A(([0-9a-f]{1,4}:){1,7}|:):\Z)|
(\A:(:[0-9a-f]{1,4}){1,7}\Z)|
(\A((([0-9a-f]{1,4}:){6})(25[0-5]|2[0-4]\d|[0-1]?\d?\d)(\.(25[0-5]|2[0-4]\d|[0-1]?\d?\d)){3})\Z)|
(\A(([0-9a-f]{1,4}:){5}[0-9a-f]{1,4}:(25[0-5]|2[0-4]\d|[0-1]?\d?\d)(\.(25[0-5]|2[0-4]\d|[0-1]?\d?\d)){3})\Z)|
(\A([0-9a-f]{1,4}:){5}:[0-9a-f]{1,4}:(25[0-5]|2[0-4]\d|[0-1]?\d?\d)(\.(25[0-5]|2[0-4]\d|[0-1]?\d?\d)){3}\Z)|
(\A([0-9a-f]{1,4}:){1,1}(:[0-9a-f]{1,4}){1,4}:(25[0-5]|2[0-4]\d|[0-1]?\d?\d)(\.(25[0-5]|2[0-4]\d|[0-1]?\d?\d)){3}\Z)|
(\A([0-9a-f]{1,4}:){1,2}(:[0-9a-f]{1,4}){1,3}:(25[0-5]|2[0-4]\d|[0-1]?\d?\d)(\.(25[0-5]|2[0-4]\d|[0-1]?\d?\d)){3}\Z)|
(\A([0-9a-f]{1,4}:){1,3}(:[0-9a-f]{1,4}){1,2}:(25[0-5]|2[0-4]\d|[0-1]?\d?\d)(\.(25[0-5]|2[0-4]\d|[0-1]?\d?\d)){3}\Z)|
(\A([0-9a-f]{1,4}:){1,4}(:[0-9a-f]{1,4}){1,1}:(25[0-5]|2[0-4]\d|[0-1]?\d?\d)(\.(25[0-5]|2[0-4]\d|[0-1]?\d?\d)){3}\Z)|
(\A(([0-9a-f]{1,4}:){1,5}|:):(25[0-5]|2[0-4]\d|[0-1]?\d?\d)(\.(25[0-5]|2[0-4]\d|[0-1]?\d?\d)){3}\Z)|
(\A:(:[0-9a-f]{1,4}){1,5}:(25[0-5]|2[0-4]\d|[0-1]?\d?\d)(\.(25[0-5]|2[0-4]\d|[0-1]?\d?\d)){3}\Z)

Regulären Ausdruck wie diesen sollte ein "code smell", der vielleicht reguläre Ausdrücke sind nicht die am besten geeignet Lösung hier. (Obwohl, ich denke, der op hat Fragen...)
Who cares, wenn es funktioniert?
jeder, der gesehen hat, eine code-Basis, die mit Bausünden wie das
Wie über den port?
Dies ist eine völlig unnötige Travestie, REs. Das Programm, das Sie erzeugt nicht verstehen, was es macht. Ein Mensch würde das nie tun, es auf diese Weise. Lassen Sie sich nicht täuschen durch die scheinbare Komplexität - REs sind ja "schwarze Magie" für viele Menschen, aber es gibt keinen Grund, legen Sie Sie auf einem anderen Planeten!

InformationsquelleAutor Factor Mystic

19

Es klingt wie Sie möglicherweise verwenden Python. Wenn ja, können Sie etwas wie dieses:
```
import socket

def check_ipv6(n):
    try:
        socket.inet_pton(socket.AF_INET6, n)
        return True
    except socket.error:
        return False

print check_ipv6('::1') # True
print check_ipv6('foo') # False
print check_ipv6(5)     # TypeError exception
print check_ipv6(None)  # TypeError exception
```
Ich glaube nicht, dass Sie haben, um IPv6 kompiliert in Python zu bekommen inet_pton, die können auch analysieren IPv4-Adressen wenn Sie socket.AF_INET als ersten parameter. Hinweis: dies funktioniert nicht auf nicht-Unix-Systeme.

Sie sollten angeben, den Typ der Ausnahme, die in der except - Klausel. Ansonsten except fangen alles und kann die Maske nicht damit zusammenhängende Fehler. Der Typ sollte hier socket.error.
A) inet_pton nicht werfen anderen Ausnahmen, es sei denn, die Dokumente sind falsch, und B) selbst wenn es das täte, was würden Sie sonst noch zurück, aber Falsch?
Re: anderer Fehler... wenn der Benutzer geht in einem nicht-string, TypeError wird gegessen. Klar die Liste ist nicht ipv6, aber ich würde wahrscheinlich wollen, haben es auf Karpfen, ich war vorbei, in der falsche Typ.
+1 Das hat mir sehr geholfen. Ein paar zusätzliche Punkte, die Hinzugefügt werden soll: 1) - Buchse.inet_pton kann verwendet werden, testen Sie die Gültigkeit der beiden Familien von IP-Adressen (IP-und IPv6). 2) Die docs hier (docs.python.org/2/library/socket.html) nahe, dass diese auf Unix-Plattformen. Es kann nicht auf Win-Plattformen.
mit django und das hilft!

InformationsquelleAutor Joe Hildebrand
8

Ich würde dringend die zweite die Antwort von Frank Krüger.

Während Sie sagen, müssen Sie einen regulären Ausdruck, der eine IPv6-Adresse, ich gehe davon aus, dass das, was Sie wirklich brauchen, ist zu überprüfen, ob ein gegebener string eine gültige IPv6-Adresse. Es ist ein subtiler, aber wichtiger Unterschied hier.

Gibt es mehr als eine Möglichkeit zu prüfen ob ein gegebener string eine gültige IPv6-Adresse und reguläre Ausdrücke nur eine Lösung.

Verwenden Sie eine vorhandene Bibliothek, wenn Sie können. Die Bibliothek wird weniger bugs und seine Verwendung führt zu weniger code für Sie zu pflegen.

Den regulären Ausdruck vorgeschlagen, die von Faktor Mystic ist lang und Komplex. Es wahrscheinlich funktioniert, aber Sie sollten auch betrachten, wie würden Sie zurechtkommen, wenn es unerwartet ausfällt. Der Punkt, den ich versuche zu machen ist hier, dass, wenn Sie nicht form einer gewünschten regulären Ausdruck selbst werden Sie nicht in der Lage, leicht zu Debuggen.

Wenn man keine geeignete Bibliothek, ist es vielleicht besser zu schreiben, Ihre eigene IPv6-Validierungs-routine, die nicht davon abhängig, reguläre Ausdrücke. Wenn Sie es schreiben Sie es verstehen und wenn Sie das verstehen, können Sie Kommentare hinzufügen, um es zu erklären, so dass andere auch verstehen und anschließend zu pflegen.

Handeln Sie mit Vorsicht, wenn Sie mit einem regulären Ausdruck, dessen Funktionalität man nicht erklären kann, um jemand anderes.

Die Verwendung von zwei regulären Ausdrücken, eine liberale Ausdruck und ein Ausdruck Ausnahmen auffangen ungültige Adressen dürfen von der ersten, könnte einfacher sein als ein Ausdruck (return ex1.match(S) && ! ex2.match(S)).
Sie gehen davon aus, dass er die Validierung von einzelnen IPs, wenn er fast sicher auf der Suche für IPs in einem großen Textblock.

InformationsquelleAutor Jon Cram
7

Ich bin kein Ipv6 Experte, aber ich denke, dass kann man ein Recht gutes Ergebnis leichter mit diesem hier:
```
^([0-9A-Fa-f]{0,4}:){2,7}([0-9A-Fa-f]{1,4}$|((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)(\.|$)){4})$
```
beantworten "ist eine gültige ipv6 -" es Aussehen ok für mich. Um es zu brechen in Teile... vergiss es. Habe ich weggelassen, die nicht spezifiziert (::), da gibt es keine Verwendung zu haben "unpecified Adresse" in meine Datenbank.

den Anfang:
^([0-9A-Fa-f]{0,4}:){2,7} <-- match das kompressible Teil, können wir es übersetzen als: zwischen 2 und 7 Doppelpunkt, der möglicherweise heaxadecimal Zahl zwischen Ihnen.

gefolgt von:
[0-9A-Fa-f]{1,4}$ <-- eine hexadezimale Zahl (führende 0 weggelassen werden).
ODER
((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)(\.|$)){4} <-- eine Ipv4-Adresse

+1 für das festhalten an der OPs Frage und präsentiert eine relativ gut aussehend regex, dass etwas funktioniert.
Diese don ' T match "::1"
Huh? In java-regex-syntaxt passt: start() = 0, end() = 3 group(0) = "::1" group(1) = ":" group(2) = "1" group(3) = "null" group(4) = "null" group(5) = "null"
Woanders jemanden Benachrichtigen Sie mich über ein problem mit meinem regex, komprimierte Teil "::" nur einmal vorkommen kann. So ist "::1::2" würde passen mit meinem regex, aber es ist nicht eine gültige IPV6. Eine zweite regex überprüfen kann diesem Fall. Die vollständige Empfehlung war die Verwendung eines stateful-parser zu validieren. Ich bin damit einverstanden, dass der resultierende code wird leichter zu Lesen und zu warten (und jemand vielleicht schon codiert es in einer open-source irgendwo).

InformationsquelleAutor Remi Morin

Dieser reguläre Ausdruck mit gültige IPv6-und IPv4-Adressen, die in übereinstimmung mit dem GNU-C++ - Umsetzung von regex mit REGELMÄßIGEN EXTENDED Modus verwendet wird:

"^\s*((([0-9A-Fa-f]{1,4}:){7}([0-9A-Fa-f]{1,4}|:))|(([0-9A-Fa-f]{1,4}:){6}(:[0-9A-Fa-f]{1,4}|((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])(\.(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])){3})|:))|(([0-9A-Fa-f]{1,4}:){5}(((:[0-9A-Fa-f]{1,4}){1,2})|:((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])(\.(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])){3})|:))|(([0-9A-Fa-f]{1,4}:){4}(((:[0-9A-Fa-f]{1,4}){1,3})|((:[0-9A-Fa-f]{1,4})?:((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])(\.(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])){3}))|:))|(([0-9A-Fa-f]{1,4}:){3}(((:[0-9A-Fa-f]{1,4}){1,4})|((:[0-9A-Fa-f]{1,4}){0,2}:((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])(\.(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])){3}))|:))|(([0-9A-Fa-f]{1,4}:){2}(((:[0-9A-Fa-f]{1,4}){1,5})|((:[0-9A-Fa-f]{1,4}){0,3}:((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])(\.(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])){3}))|:))|(([0-9A-Fa-f]{1,4}:){1}(((:[0-9A-Fa-f]{1,4}){1,6})|((:[0-9A-Fa-f]{1,4}){0,4}:((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])(\.(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])){3}))|:))|(:(((:[0-9A-Fa-f]{1,4}){1,7})|((:[0-9A-Fa-f]{1,4}){0,5}:((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])(\.(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])){3}))|:)))(%.+)?\s*$"

InformationsquelleAutor janCoffee

Achtung! In Java ist die Verwendung von InetAddress und Verwandte Klassen (Inet4Address, Inet6Address, URL) kann auch Netzwerk-trafic! E. g. DNS-Auflösung (URL.gleich, InetAddress from string!). Dieser Aufruf kann lange dauern und blockiert!

Für IPv6 habe ich so etwas wie dieses. Das macht natürlich nicht mit den feinen details von IPv6 wie zone Indizes sind nur gestattet, auf einige Klassen von IPv6-Adressen. Und dieser regex ist nicht geschrieben für die Gruppe aufnehmen, es ist nur ein "entspricht" Art von regexp.

S - IPv6-segment = [0-9a-f]{1,4}

I - IPv4 = (?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9]{1,2})\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9]{1,2})

Schaltplan (der erste Teil entspricht der IPv6-Adressen mit IPv4-suffix, der zweite Teil entspricht IPv6-Adressen, im letzten patrt die zone index):

(
(
::(S:){0,5}|
S::(S:){0,4}|
(S:){2}:(S:){0,3}|
(S:){3}:(S:){0,2}|
(S:){4}:(S:)?|
(S:){5}:|
(S:){6}
)
I

|

:(:|(:S){1,7})|
S:(:|(:S){1,6})|
(S:){2}(:|(:S){1,5})|
(S:){3}(:|(:S){1,4})|
(S:){4}(:|(:S){1,3})|
(S:){5}(:|(:S){1,2})|
(S:){6}(:|(:S))|
(S:){7}:|
(S:){7}S
)

(?:%[0-9a-z]+)?

Und hier könnte die regex (groß-und Kleinschreibung, umgeben mit dem, was jemals benötigt wie Anfang/Ende der Zeile, usw.):

(?:
(?:
::(?:[0-9a-f]{1,4}:){0,5}|
[0-9a-f]{1,4}::(?:[0-9a-f]{1,4}:){0,4}|
(?:[0-9a-f]{1,4}:){2}:(?:[0-9a-f]{1,4}:){0,3}|
(?:[0-9a-f]{1,4}:){3}:(?:[0-9a-f]{1,4}:){0,2}|
(?:[0-9a-f]{1,4}:){4}:(?:[0-9a-f]{1,4}:)?|
(?:[0-9a-f]{1,4}:){5}:|
(?:[0-9a-f]{1,4}:){6}
)
(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9]{1,2})\.){3}
(?:25[0-5]|2[0-4][0-9]|[01]?[0-9]{1,2})|

:(?::|(?::[0-9a-f]{1,4}){1,7})|
[0-9a-f]{1,4}:(?::|(?::[0-9a-f]{1,4}){1,6})|
(?:[0-9a-f]{1,4}:){2}(?::|(?::[0-9a-f]{1,4}){1,5})|
(?:[0-9a-f]{1,4}:){3}(?::|(?::[0-9a-f]{1,4}){1,4})|
(?:[0-9a-f]{1,4}:){4}(?::|(?::[0-9a-f]{1,4}){1,3})|
(?:[0-9a-f]{1,4}:){5}(?::|(?::[0-9a-f]{1,4}){1,2})|
(?:[0-9a-f]{1,4}:){6}(?::|(?::[0-9a-f]{1,4}))|
(?:[0-9a-f]{1,4}:){7}:|
(?:[0-9a-f]{1,4}:){7}[0-9a-f]{1,4}
)

(?:%[0-9a-z]+)?

InformationsquelleAutor user2623580

3

Einem einfachen regex übereinstimmt, aber ich würde nicht empfehlen für die Validierung jeglicher Art ist diese:
```
([A-Fa-f0-9]{1,4}::?){1,7}[A-Fa-f0-9]{1,4}
```
Hinweis: dies entspricht der Kompression überall in der Adresse, obwohl es wird nicht mit dem loopback-Adresse ::1 ist. Ich finde dies einen vernünftigen Kompromiss, um den regex einfach.

Habe ich erfolgreich in iTerm2 intelligente Auswahl-Regeln quad-klicken Sie auf IPv6-Adressen.

Sie meinte A-F, nicht A-Z! Beachten Sie auch, dass Sie ohne dotted-quad-notation.

InformationsquelleAutor JinnKo

Wenn Sie mit Perl versuchen Net::IPv6Addr

use Net::IPv6Addr;

if( defined Net::IPv6Addr::is_ipv6($ip_address) ){
  print "Looks like an ipv6 address\n";
}

NetAddr::IP

use NetAddr::IP;

my $obj = NetAddr::IP->new6($ip_address);

Validate::IP

use Validate::IP qw'is_ipv6';

if( is_ipv6($ip_address) ){
  print "Looks like an ipv6 address\n";
}

Oder Data::Validate::IP search.cpan.org/~neely/Daten-Überprüfen-IP-0.11/lib/Data/Validate/....

InformationsquelleAutor Brad Gilbert

3

Dieser fängt den loopback(::1) gut-und ipv6-Adressen.
geändert {} + und setzen : in der ersten eckigen Klammer.
```
([A-f0-9:]+:+)+[A-f0-9]+
```
getestet mit ifconfig-a die Ausgabe
http://regexr.com/

Unix-oder Mac OSx-terminal a-option gibt nur die passende Ausgabe(ipv6) inklusive: 1
```
ifconfig -a | egrep -o '([A-f0-9:]+:+)+[A-f0-9]+'
```
Erhalten Sie Alle IP-Adressen (IPv4 ODER IPv6) und Druck-match auf unix OSx Begriff
```
ifconfig -a | egrep -o '([0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}) | (([A-f0-9:]+:+)+[A-f0-9]+)'
```
Ich mag die Einfachheit. Die schließlich für mich gearbeitet: ip a | grep -Po '[\w:]+:+[\w:]+'
Humor geschätzt!

InformationsquelleAutor Rohit Malgaonkar

In Scala verwenden Sie den bekannten Apache-Commons-Prüfungen.

http://mvnrepository.com/artifact/commons-validator/commons-validator/1.4.1

libraryDependencies += "commons-validator" % "commons-validator" % "1.4.1"


import org.apache.commons.validator.routines._

/**
 * Validates if the passed ip is a valid IPv4 or IPv6 address.
 *
 * @param ip The IP address to validate.
 * @return True if the passed IP address is valid, false otherwise.
 */  
 def ip(ip: String) = InetAddressValidator.getInstance().isValid(ip)

Folgenden der test der Methode ip(ip: String):

"The `ip` validator" should {
  "return false if the IPv4 is invalid" in {
    ip("123") must beFalse
    ip("255.255.255.256") must beFalse
    ip("127.1") must beFalse
    ip("30.168.1.255.1") must beFalse
    ip("-1.2.3.4") must beFalse
  }

  "return true if the IPv4 is valid" in {
    ip("255.255.255.255") must beTrue
    ip("127.0.0.1") must beTrue
    ip("0.0.0.0") must beTrue
  }

  //IPv6
  //@see: http://www.ronnutter.com/ipv6-cheatsheet-on-identifying-valid-ipv6-addresses/
  "return false if the IPv6 is invalid" in {
    ip("1200::AB00:1234::2552:7777:1313") must beFalse
  }

  "return true if the IPv6 is valid" in {
    ip("1200:0000:AB00:1234:0000:2552:7777:1313") must beTrue
    ip("21DA:D3:0:2F3B:2AA:FF:FE28:9C5A") must beTrue
  }
}

Interessant ist, Ansprüche zu überprüfen, die eine gültige Adresse "Überprüft, ob die übergebene ip ist eine gültige IPv4-oder IPv6-Adresse.", aber es ist wirklich nur überprüft, es ist formatiert als eine gültige Adresse. Zum Beispiel 1200:0000:AB00:1234:0000:2552:7777:1313 ist ein gültiges format für eine IPv6-Adresse, aber es ist nicht eine gültige IPv6-Adresse als test-Methode gibt. Ich Wette, er denkt 241.54.113.65 ist eine gültige IPv4-Adresse.

InformationsquelleAutor OliverKK

Es ist schwierig, einen regulären Ausdruck funktioniert für alle IPv6-Fällen. Sie sind in der Regel schwer zu pflegen, nicht leicht lesbaren und möglicherweise zu Leistungsproblemen führen. Daher möchte ich eine alternative Lösung, die ich entwickelt habe: Regulärer Ausdruck (RegEx) für IPv6 Getrennt von IPv4

Nun mögen Sie sich Fragen, "dass Diese Methode nur IPv6 findet, wie finde ich die IPv6 in eine text-Datei oder?" Hier sind Methoden für dieses Problem auch.

Hinweis: Wenn Sie nicht möchten, zu verwenden IPAddress-Klasse .NET, Sie können auch ersetzen Sie es mit meine Methode. Es umfasst auch zugeordnete IPv4-und Spezial-Fällen, während die IP-Adresse nicht abgedeckt werden.

class IPv6
{
    public List<string> FindIPv6InFile(string filePath)
    {
        Char ch;
        StringBuilder sbIPv6 = new StringBuilder();
        List<string> listIPv6 = new List<string>();
        StreamReader reader = new StreamReader(filePath);
        do
        {
            bool hasColon = false;
            int length = 0;

            do
            {
                ch = (char)reader.Read();

                if (IsEscapeChar(ch))
                    break;

                //Check the first 5 chars, if it has colon, then continue appending to stringbuilder
                if (!hasColon && length < 5)
                {
                    if (ch == ':')
                    {
                        hasColon = true;
                    }
                    sbIPv6.Append(ch.ToString());
                }
                else if (hasColon) //if no colon in first 5 chars, then dont append to stringbuilder
                {
                    sbIPv6.Append(ch.ToString());
                }

                length++;

            } while (!reader.EndOfStream);

            if (hasColon && !listIPv6.Contains(sbIPv6.ToString()) && IsIPv6(sbIPv6.ToString()))
            {
                listIPv6.Add(sbIPv6.ToString());
            }

            sbIPv6.Clear();

        } while (!reader.EndOfStream);
        reader.Close();
        reader.Dispose();

        return listIPv6;
    }

    public List<string> FindIPv6InText(string text)
    {
        StringBuilder sbIPv6 = new StringBuilder();
        List<string> listIPv6 = new List<string>();

        for (int i = 0; i < text.Length; i++)
        {
            bool hasColon = false;
            int length = 0;

            do
            {
                if (IsEscapeChar(text[length + i]))
                    break;

                //Check the first 5 chars, if it has colon, then continue appending to stringbuilder
                if (!hasColon && length < 5)
                {
                    if (text[length + i] == ':')
                    {
                        hasColon = true;
                    }
                    sbIPv6.Append(text[length + i].ToString());
                }
                else if (hasColon) //if no colon in first 5 chars, then dont append to stringbuilder
                {
                    sbIPv6.Append(text[length + i].ToString());
                }

                length++;

            } while (i + length != text.Length);

            if (hasColon && !listIPv6.Contains(sbIPv6.ToString()) && IsIPv6(sbIPv6.ToString()))
            {
                listIPv6.Add(sbIPv6.ToString());
            }

            i += length;
            sbIPv6.Clear();
        }

        return listIPv6;
    }

    bool IsEscapeChar(char ch)
    {
        if (ch != ' ' && ch != '\r' && ch != '\n' && ch!='\t')
        {
            return false;
        }

        return true;
    }

    bool IsIPv6(string maybeIPv6)
    {
        IPAddress ip;
        if (IPAddress.TryParse(maybeIPv6, out ip))
        {
            return ip.AddressFamily == AddressFamily.InterNetworkV6;
        }
        else
        {
            return false;
        }
    }

}

InformationsquelleAutor Nuh Metin Güler

InetAddressUtils hat alle Muster definiert. Ich endete-mit Ihrem Muster direkt, und bin einfügen hier zur Referenz:

private static final String IPV4_BASIC_PATTERN_STRING =
        "(([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])\\.){3}" + //initial 3 fields, 0-255 followed by .
         "([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])"; //final field, 0-255

private static final Pattern IPV4_PATTERN =
    Pattern.compile("^" + IPV4_BASIC_PATTERN_STRING + "$");

private static final Pattern IPV4_MAPPED_IPV6_PATTERN = //TODO does not allow for redundant leading zeros
        Pattern.compile("^::[fF]{4}:" + IPV4_BASIC_PATTERN_STRING + "$");

private static final Pattern IPV6_STD_PATTERN =
    Pattern.compile(
            "^[0-9a-fA-F]{1,4}(:[0-9a-fA-F]{1,4}){7}$");

private static final Pattern IPV6_HEX_COMPRESSED_PATTERN =
    Pattern.compile(
            "^(([0-9A-Fa-f]{1,4}(:[0-9A-Fa-f]{1,4}){0,5})?)" + //0-6 hex fields
             "::" +
             "(([0-9A-Fa-f]{1,4}(:[0-9A-Fa-f]{1,4}){0,5})?)$"); //0-6 hex fields

InformationsquelleAutor user4604205

Blick auf die Muster enthalten, die in den anderen Antworten gibt es eine Reihe von guten mustern, die verbessert werden können durch die Referenzierung von Gruppen und die Nutzung von lookaheads. Hier ist ein Beispiel für ein Muster, das ist selbst-referenzierend, ich würde nutzen in PHP, wenn ich musste:

^(?<hgroup>(?<hex>[[:xdigit:]]{0,4}) # grab a sequence of up to 4 hex digits
                                     # and name this pattern for usage later
     (?<!:::):{1,2})                 # match 1 or 2 ':' characters
                                     # as long as we can't match 3
 (?&hgroup){1,6} # match our hex group 1 to 6 more times
 (?:(?:
    # match an ipv4 address or
    (?<dgroup>2[0-5]|(?:2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3}(?&dgroup)
    # match our hex group one last time
    |(?&hex))$

Hinweis: PHP hat einen eingebauten filter für diese, das wäre eine bessere Lösung als diese
Muster.

Regex101 Analyse

InformationsquelleAutor Steve Buzonas

Ruby? Versuchen Sie dies:

/^(((?=.*(::))(?!.*\3.+\3))\3?|[\dA-F]{1,4}:)([\dA-F]{1,4}(\3|:\b)|\2){5}(([\dA-F]{1,4}(\3|:\b|$)|\2){2}|(((2[0-4]|1\d|[1-9])?\d|25[0-5])\.?\b){4})\z/i

InformationsquelleAutor Ahamx

1

Je nach Ihren Bedürfnissen, eine Annäherung, wie:
```
[0-9a-f:]+
```
ausreichend sein kann (wie mit einfachen log-Datei grepping, zum Beispiel.)

InformationsquelleAutor Bill Lipa
1

Folgenden regex ist für IPv6. Gruppe 1 matches mit der IP.
```
(([0-9a-fA-F]{0,4}:){1,7}[0-9a-fA-F]{0,4})
```
+1 Es ist nicht immer notwendig, um eine perfekte super-komplexe regex, die ein Mensch nicht verstehen kann. Ich verwende diese, weil ich verstehe, was es tut und in meinem Fall kann ich mir sicher sein, dass wenn ich etwas, das ähnelt eine gültige ipv6, so ist es eine gültige ipv6.
dies würde nicht übereinstimmen, sagen: fe80::1 oder 2342:32fd::2d32

InformationsquelleAutor Jitendra Gosavi
0

In Java, können Sie die Bibliothek-Klasse sun.net.util.IPAddressUtil:
```
IPAddressUtil.isIPv6LiteralAddress(iPaddress);
```
sun.net.* private API.

InformationsquelleAutor user463639
0

Für PHP 5.2+ Benutzer filter_var Super funktioniert.

Ich weiß, das beantwortet nicht die ursprüngliche Frage (speziell eine regex-Lösung), aber ich poste das, in der Hoffnung, Sie kann helfen, jemand anderes in der Zukunft.
```
$is_ip4address = (filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_IPV4) !== FALSE);
$is_ip6address = (filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_IPV6) !== FALSE);
```
InformationsquelleAutor Wireblue
0

Dieser Arbeit wird für IPv4 und IPv6:
```
^(([0-9a-f]{0,4}:){1,7}[0-9a-f]{1,4}|([0-9]{1,3}\.){3}[0-9]{1,3})$
```
Es entspricht ungültige Adressen mit 2 Instanzen von ::. z.B. 2404:6800::4003:c02::8a
passt ungültige IPv4-666.666.666.666

InformationsquelleAutor Chris
0

Hier ist, was ich kam mit, mit ein bisschen lookahead und benannte Gruppen. Dies ist natürlich nur IPv6, aber Sie sollten nicht mit zusätzlichen Muster, wenn Sie möchten, fügen Sie die IPv4:
```
(?=([0-9a-f]+(:[0-9a-f])*)?(?P<wild>::)(?!([0-9a-f]+:)*:))(::)?([0-9a-f]{1,4}:{1,2}){0,6}(?(wild)[0-9a-f]{0,4}|[0-9a-f]{1,4}:[0-9a-f]{1,4})
```
InformationsquelleAutor user1977022
0

Können Sie die ipextract shell tools ich für diesen Zweck hergestellt. Sie basieren auf regexp und grep.

Verwendung:
```
$ ifconfig | ipextract6
fe80::1%lo0
::1
fe80::7ed1:c3ff:feec:dee1%en0
```
InformationsquelleAutor Phil L.

Generiert ich die folgenden using-python und arbeitet mit dem re-Modul. Die look-ahead-assertions sicherzustellen, dass die richtige Anzahl von Punkten oder Doppelpunkten angezeigt, in der Adresse. Es unterstützt keine IPv4-in IPv6-notation.

pattern = '^(?=\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$)(?:(?:25[0-5]|[12][0-4][0-9]|1[5-9][0-9]|[1-9]?[0-9])\.?){4}$|(?=^(?:[0-9a-f]{0,4}:){2,7}[0-9a-f]{0,4}$)(?![^:]*::.+::[^:]*$)(?:(?=.*::.*)|(?=\w+:\w+:\w+:\w+:\w+:\w+:\w+:\w+))(?:(?:^|:)(?:[0-9a-f]{4}|[1-9a-f][0-9a-f]{0,3})){0,8}(?:::(?:[0-9a-f]{1,4}(?:$|:)){0,6})?$'
result = re.match(pattern, ip)
if result: result.group(0)

InformationsquelleAutor Mike Wilmes

0

Nur passenden lokalen, von einem Ursprung mit eckigen Klammern enthalten. Ich weiß, es ist nicht so umfassend, aber in javascript, die anderen hatten schwer zu verfolgen, Fragen in Erster Linie, dass der nicht funktioniert, so scheint dies für mich zu bekommen, was ich brauchte jetzt. extra Hauptstädte A-F sind nicht erforderlich.
```
^\[([0-9a-fA-F]{1,4})(\:{1,2})([0-9a-fA-F]{1,4})(\:{1,2})([0-9a-fA-F]{1,4})(\:{1,2})([0-9a-fA-F]{1,4})(\:{1,2})([0-9a-fA-F]{1,4})\]
```
Jinnko version ist vereinfacht und besser sehe ich.

InformationsquelleAutor Master James

Wird, wie oben angegeben, ein weiterer Weg, um eine IPv6-textliche Darstellung Validierung parser zu Programmieren. Hier ist eine, die ist vollständig kompatibel mit RFC 4291 RFC-5952. Ich habe geschrieben diesen code in ANSI-C (arbeitet mit GCC), der bestandenen tests auf Linux - funktioniert auch mit clang, der bestandenen tests auf FreeBSD). So, es tut nur verlassen sich auf den ANSI-C-standard-Bibliothek, so kann es kompiliert werden überall (ich habe es verwendet für IPv6-parsing innerhalb eines kernel-Moduls mit FreeBSD).

//IPv6 textual representation validating parser fully compliant with RFC-4291 and RFC-5952
//BSD-licensed /Copyright 2015-2017 Alexandre Fenyo

#include <string.h>
#include <netinet/in.h>
#include <stdlib.h>
#include <stdio.h>
#include <ctype.h>

typedef enum { false, true } bool;

static const char hexdigits[] = "0123456789abcdef";
static int digit2int(const char digit) {
  return strchr(hexdigits, digit) - hexdigits;
}

//This IPv6 address parser handles any valid textual representation according to RFC-4291 and RFC-5952.
//Other representations will return -1.
//
//note that str input parameter has been modified when the function call returns
//
//parse_ipv6(char *str, struct in6_addr *retaddr)
//parse textual representation of IPv6 addresses
//str:     input arg
//retaddr: output arg
int parse_ipv6(char *str, struct in6_addr *retaddr) {
  bool compressed_field_found = false;
  unsigned char *_retaddr = (unsigned char *) retaddr;
  char *_str = str;
  char *delim;

  bzero((void *) retaddr, sizeof(struct in6_addr));
  if (!strlen(str) || strchr(str, ':') == NULL || (str[0] == ':' && str[1] != ':') ||
      (strlen(str) >= 2 && str[strlen(str) - 1] == ':' && str[strlen(str) - 2] != ':')) return -1;

  //convert transitional to standard textual representation
  if (strchr(str, '.')) {
    int ipv4bytes[4];
    char *curp = strrchr(str, ':');
    if (curp == NULL) return -1;
    char *_curp = ++curp;
    int i;
    for (i = 0; i < 4; i++) {
      char *nextsep = strchr(_curp, '.');
      if (_curp[0] == '0' || (i < 3 && nextsep == NULL) || (i == 3 && nextsep != NULL)) return -1;
      if (nextsep != NULL) *nextsep = 0;
      int j;
      for (j = 0; j < strlen(_curp); j++) if (_curp[j] < '0' || _curp[j] > '9') return -1;
      if (strlen(_curp) > 3) return -1;
      const long val = strtol(_curp, NULL, 10);
      if (val < 0 || val > 255) return -1;
      ipv4bytes[i] = val;
      _curp = nextsep + 1;
    }
    sprintf(curp, "%x%02x:%x%02x", ipv4bytes[0], ipv4bytes[1], ipv4bytes[2], ipv4bytes[3]);
  }

  //parse standard textual representation
  do {
    if ((delim = strchr(_str, ':')) == _str || (delim == NULL && !strlen(_str))) {
      if (delim == str) _str++;
      else if (delim == NULL) return 0;
      else {
        if (compressed_field_found == true) return -1;
        if (delim == str + strlen(str) - 1 && _retaddr != (unsigned char *) (retaddr + 1)) return 0;
        compressed_field_found = true;
        _str++;
        int cnt = 0;
        char *__str;
        for (__str = _str; *__str; ) if (*(__str++) == ':') cnt++;
        unsigned char *__retaddr = - 2 * ++cnt + (unsigned char *) (retaddr + 1);
        if (__retaddr <= _retaddr) return -1;
        _retaddr = __retaddr;
      }
    } else {
      char hexnum[4] = "0000";
      if (delim == NULL) delim = str + strlen(str);
      if (delim - _str > 4) return -1;
      int i;
      for (i = 0; i < delim - _str; i++)
        if (!isxdigit(_str[i])) return -1;
        else hexnum[4 - (delim - _str) + i] = tolower(_str[i]);
      _str = delim + 1;
      *(_retaddr++) = (digit2int(hexnum[0]) << 4) + digit2int(hexnum[1]);
      *(_retaddr++) = (digit2int(hexnum[2]) << 4) + digit2int(hexnum[3]);
    }
  } while (_str < str + strlen(str));
  return 0;
}

InformationsquelleAutor Alexandre Fenyo

Regexes für ipv6 kann man wirklich schwierig, wenn man bedenkt, Adressen mit eingebetteten ipv4-Adressen, die komprimiert werden, wie Sie sehen können, die von einigen dieser Antworten.

Die open-source-IP-Adresse Java-Bibliothek wird, überprüfen Sie alle standard-Darstellungen von IPv6-und IPv4-und unterstützt auch die Präfix-Länge (und Validierung eines solchen). Disclaimer: ich bin der Projekt manager der Bibliothek.

Code Beispiel:

        try {
            IPAddressString str = new IPAddressString("::1");
            IPAddress addr = str.toAddress();
            if(addr.isIPv6() || addr.isIPv6Convertible()) {
                IPv6Address ipv6Addr = addr.toIPv6();
            }
            //use address
        } catch(AddressStringException e) {
            //e.getMessage has validation error
        }

InformationsquelleAutor Sean F

-1

Versuchen, diese kleine one-liner. Es sollte nur entsprechen, gilt nicht komprimierte/komprimierte IPv6-Adressen (keine IPv4-Hybriden)
```
/(?!.*::.*::)(?!.*:::.*)(?!:[a-f0-9])((([a-f0-9]{1,4})?[:](?!:)){7}|(?=(.*:[:a-f0-9]{1,4}::|^([:a-f0-9]{1,4})?::))(([a-f0-9]{1,4})?[:]{1,2}){1,6})[a-f0-9]{1,4}/
```
Eigentlich gültige IPv6-Adressen sind unkomprimiert, komprimiert, unkomprimiert-hybrid, und komprimiert hybrid. Es dauert wirklich eine Menge mehr als was Sie eigentlich mit jeder gültigen text-Darstellung einer IPv6-Adresse.

InformationsquelleAutor Carlos Velazquez
-2

Regex ermöglicht die Verwendung von führenden Nullen in der IPv4-Teile.

Einige Unix-und Mac-Distributionen konvertieren diese Segmente in octals.

Schlage ich vor, mit 25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d als IPv4-segment.

InformationsquelleAutor Aeron
-2

Wenn Sie wollen nur normale IP-s (ohne Schrägstriche), hier:
```
^(?:[0-9a-f]{1,4}(?:::)?){0,7}::[0-9a-f]+$
```
Ich benutze es für mein syntax-highlighter in der hosts-Datei-editor-Anwendung. Funktioniert wie Charme.

Keine Möglichkeit, dass dies jemals funktioniert anständig, es kann nicht mit einer einzelnen ipv6-Adresse mit einem einzigen Doppelpunkt in es, alle Ihre Spiele sind auf die doppelten Doppelpunkte, und Sie explizit eine doppelte Doppelpunkt für Ihre Letzte Gruppe, die Verdichtung kann überall passieren... .
(?:[0-9a-f]{1,4}(?:::?)?){0,7}::?[0-9a-f]{1,4}
Immer noch falsch, aber selbst dann werden Sie am Ende wiederholen JinnKo Antwort, die ist gut genug für einfache Zwecke, aber hat immer noch Fehler (nicht fangen Doppel-Verdichtung und nicht zulassen dotted quads, noch localhost, nor :: Kündigung, ...)

InformationsquelleAutor Harry

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.