Überprüfen von IPv4-Adressen mit regulärem Ausdruck

92

Ich habe versucht, einen effizienten regulären Ausdruck für die IPv4-Validierung zu erhalten, aber ohne viel Glück. Es schien an einem Punkt, an dem ich es hatte (25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?(\.|$)){4}, aber es führt zu einigen seltsamen Ergebnissen:

$ grep --version
grep (GNU grep) 2.7
$ grep -E '\b(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?(\.|$)){4}\b' <<< 192.168.1.1
192.168.1.1
$ grep -E '\b(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?(\.|$)){4}\b' <<< 192.168.1.255
192.168.1.255
$ grep -E '\b(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?(\.|$)){4}\b' <<< 192.168.255.255
$ grep -E '\b(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?(\.|$)){4}\b' <<< 192.168.1.2555
192.168.1.2555

Ich habe eine Suche durchgeführt, um festzustellen, ob dies bereits gefragt und beantwortet wurde, aber andere Antworten scheinen einfach zu zeigen, wie man 4 Gruppen von 1-3 Zahlen bestimmt, oder funktionieren nicht für mich.

Matthieu Cartier
quelle
12
Vergessen Sie nicht, dass A, AB und ABC gültige Formen der IP-Adresse sowie ABCD Seriously sind. Versuchen Sie ping 2130706433und ping 127.1für ein Kichern.
12.
1
Meine Variante online regexr.com/39hqf
Sllouyssgort

Antworten:

96

Sie haben bereits eine funktionierende Antwort, aber für den Fall, dass Sie neugierig sind, was mit Ihrem ursprünglichen Ansatz nicht stimmte, ist die Antwort, dass Sie Klammern um Ihren Wechsel benötigen, andernfalls (\.|$)ist dies nur erforderlich, wenn die Anzahl weniger als 200 beträgt.

'\b((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)(\.|$)){4}\b'
    ^                                    ^
Mark Byers
quelle
26
Dies scheint auch Dinge wie192.168.1.1.1
cwd
2
Sollte es sein : \b((?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)(?:(?<!\.)\b|\.)){4}; dh es endet eher mit einer Wortgrenze als mit dem Zeilenende? Zusätzlich habe ich hier die nicht erfassenden Gruppen markiert, um unerwünschte Unterübereinstimmungen zu vermeiden. NB: Dies berücksichtigt immer noch nicht den Kommentar von @ dty, da ich mit dieser Form von IP nicht vertraut bin. obwohl er Recht hat, dass es gültig scheint.
JohnLBevan
Vielleicht möchten Sie dies stattdessen versuchen: ((1? \ D \ d? | 2 [0-4] \ d | 25 [0-5]) \.) {3} (1? \ D \ d? | 2 [0-4] \ d | 25 [0-5])
Morg.
Dies funktioniert gut für nicht erfassen -\b(?:(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\.){3}(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\b
Appy
3
Wird 09.09.09.09als gültige IP angesehen? Es wird auch von diesem regulären Ausdruck angepasst. Aber Ping wirft Fehlermeldungen wie ping: cannot resolve 09.09.09.09: Unknown host. Ich denke, es könnte ratsam sein, die Übereinstimmung nur auf Punkt-Dezimal-Notationsübereinstimmung zu reduzieren. In diesem Eintrag werden führende Fehler bei IP-Adressen erläutert.
Ruifeng Ma
81
^((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]?)$

Akzeptieren :

127.0.0.1
192.168.1.1
192.168.1.255
255.255.255.255
0.0.0.0
1.1.1.01        # This is an invalid IP address!

Ablehnen :

30.168.1.255.1
127.1
192.168.1.256
-1.2.3.4
1.1.1.1.
3...3

Versuchen Sie es online mit Unit-Tests: https://www.debuggex.com/r/-EDZOqxTxhiTncN6/1

Sllouyssgort
quelle
Was ist mit der IP-Adresse "3 ... 3"? 3 ... 3 wird mit diesem regulären
Ausdruck
8
Was ist mit 1.1.1.01? Wird es als gültige IPv4-Adresse angesehen? Vielen Dank.
Odieatla
Dieser reguläre Ausdruck 1.1.1.01 wird als GÜLTIGE IPv4-Adresse betrachtet. Online-Unit-Tests debuggex.com/r/-EDZOqxTxhiTncN6/1
Sllouyssgort
durch die Art und Weise ^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)(\.|$)){4}$gleiches Ergebnis debuggex.com/r/mz_-0dEm3wseIKqK , ziemlich ähnlich mit @ Mark Byers Antwort
Sllouyssgort
@PriteshAcharya Funktioniert hier gut.
Kid Diamond
39

Neueste, kürzeste, am wenigsten lesbare Version ( 55 Zeichen )

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

Diese Version sucht nach dem 250-5-Fall, danach werden alle möglichen Fälle für 200-249 100-199 10-99Fälle geschickt ODER-verknüpft . Beachten Sie, dass das |)Teil kein Fehler ist, sondern der letzte Fall für den Bereich 0-9. Ich habe auch den ?:nicht erfassbaren Gruppenteil weggelassen , da uns die erfassten Gegenstände nicht wirklich wichtig sind. Sie würden in keiner Weise erfasst, wenn wir überhaupt keine vollständige Übereinstimmung hätten.

Alte und kürzere Version (weniger lesbar) ( 63 Zeichen )

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

Ältere (lesbare) Version ( 70 Zeichen )

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

Es verwendet den negativen Lookahead (?!), um den Fall zu entfernen, in dem die IP mit einem enden könnte.

Älteste Antwort ( 115 Zeichen )

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

Ich denke, dies ist der genaueste und strengste reguläre Ausdruck. Er akzeptiert keine Dinge, wie 000.021.01.0.es bei den meisten anderen Antworten hier der Fall zu sein scheint, und erfordert einen zusätzlichen regulären Ausdruck, um ähnliche Fälle abzulehnen - dh 0Startnummern und eine IP, die mit a endet.

Danail Gabenski
quelle
Dies ist die einzig richtige Antwort in diesem Thread bis zu diesem Datum. Die anderen vermissen solche Adressen wie 0.0.0.0oder akzeptieren gemischte Oktal- / Dezimalschreibweise wie 033.033.33.033oder erlauben sogar 999.999.999.999. Wie wäre es mit dieser Regex, die 10 Zeichen kürzer als diese Antwort ist:(([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])\.){3}([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])
Anneb
1
@tinmarino Ich habe Ihre Bearbeitung zurückgesetzt, weil es Dinge wie 192.168.000.1 erlaubt hat, die keine gültige Adresse sind. Wenn Sie diese Antwort bearbeiten möchten, kommentieren Sie diese bitte zuerst hier, um Probleme wie diese zu vermeiden. Normalerweise antworte ich ziemlich schnell. Natürlich immer auf der Suche nach einer kürzeren / besseren Lösung.
Danail Gabenski
1
@DanailGabenski (und andere) für Speicher, Sie haben es gelöst und zuletzt [01]?[0-9][0-9]?durch ersetzt, 1[0-9]{2}|[1-9]?[0-9]weil Sie nicht gerne 0 führen . Nochmals vielen Dank! Ich werde Ihre Lösung in meinem Regex-Hauptgepäck aufbewahren.
Tinmarino
1
@tinmarino Ja, das Punkt-Dezimal-Format, das zum Standard für IPv4 geworden ist, obwohl es nicht offiziell akzeptiert wurde, sehen Sie sich bitte Folgendes an . Insbesondere Punkt 3, wo ein Entwurf vorgeschlagen wurde, aber abgelaufen ist. Ein sekundärer Grund für die strenge Überprüfung ist, dass IP-Adressen mit nicht dezimalen Zahlen wie 023 anstelle von 23 Benutzer in der Benutzeroberfläche dazu bringen, dass dies ein Fehler ist. Dies führt auch zu Schwierigkeiten bei der Überprüfung / Sicherheit, da 023 in 23 konvertiert werden muss, um Duplikate usw. zu vermeiden. Vielen Dank, dass Sie versucht haben, die Dinge zu verbessern!
Danail Gabenski
1
Sie können durch Ausklammern der es kürzer machen [0-9]für die 2[0-4], 1und kürzere Fälle. ^(?:(25[0-5]|(?:2[0-4]|1[0-9]|[1-9]|)[0-9])(\.(?!$)|$)){4}$
Clayton Singh
11

IPv4-Adresse (genaue Erfassung) Entspricht 0.0.0.0 bis 255.255.255.255, erfasst jedoch ungültige Adressen wie 1.1.000.1 Verwenden Sie diesen regulären Ausdruck, um IP-Nummern mit Genauigkeit abzugleichen. Jede der 4 Nummern wird in einer Erfassungsgruppe gespeichert, sodass Sie zur weiteren Verarbeitung darauf zugreifen können.

\b
(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.
(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.
(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.
(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)
\b

entnommen aus der JGsoft RegexBuddy-Bibliothek

Edit: Dieser (\.|$)Teil scheint komisch

Valerij
quelle
2
Nett! Ich habe eine effizientere Modifikation von dem gemacht, was zu funktionieren scheint: "\b(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)(\.|$){4}\b- danke!
Matthieu Cartier
2
@MatthieuCartier Ihr effizientes Regex-Muster hat bei mir nicht funktioniert,
R__raki__
1
255.255.255.000 ist keine gültige IP
Stéphane GRILLON
6

Ich war auf der Suche nach etwas Ähnlichem für IPv4-Adressen - einem regulären Ausdruck, der auch die Validierung häufig verwendeter privater IP-Adressen verhinderte (192.168.xy, 10.xyz, 172.16.xy). Daher wurden negative Vorausschau verwendet, um dies zu erreichen:

(?!(10\.|172\.(1[6-9]|2\d|3[01])\.|192\.168\.).*)
(?!255\.255\.255\.255)(25[0-5]|2[0-4]\d|[1]\d\d|[1-9]\d|[1-9])
(\.(25[0-5]|2[0-4]\d|[1]\d\d|[1-9]\d|\d)){3}

(Diese sollten natürlich in einer Zeile stehen und aus Gründen der Lesbarkeit in 3 separaten Zeilen formatiert sein.) Visualisierung regulärer Ausdrücke

Debuggex-Demo

Es ist möglicherweise nicht auf Geschwindigkeit optimiert, funktioniert aber gut, wenn nur nach "echten" Internetadressen gesucht wird.

Dinge, die scheitern werden (und sollten):

0.1.2.3         (0.0.0.0/8 is reserved for some broadcasts)
10.1.2.3        (10.0.0.0/8 is considered private)
172.16.1.2      (172.16.0.0/12 is considered private)
172.31.1.2      (same as previous, but near the end of that range)
192.168.1.2     (192.168.0.0/16 is considered private)
255.255.255.255 (reserved broadcast is not an IP)
.2.3.4
1.2.3.
1.2.3.256
1.2.256.4
1.256.3.4
256.2.3.4
1.2.3.4.5
1..3.4

IPs, die funktionieren (und sollten):

1.0.1.0         (China)
8.8.8.8         (Google DNS in USA)
100.1.2.3       (USA)
172.15.1.2      (USA)
172.32.1.2      (USA)
192.167.1.2     (Italy)

Vorausgesetzt, jemand anderes sucht nach einer Validierung von "Internet-IP-Adressen ohne die gemeinsamen privaten Adressen".

PhillipHolmes
quelle
5

Ich denke, viele Leute, die diesen Beitrag lesen, werden nach einfacheren regulären Ausdrücken suchen, selbst wenn sie mit einigen technisch ungültigen IP-Adressen übereinstimmen. (Und wie an anderer Stelle erwähnt, ist Regex wahrscheinlich sowieso nicht das richtige Werkzeug, um eine IP-Adresse ordnungsgemäß zu validieren.)

Entfernen ^und gegebenenfalls ersetzen $durch \b, wenn Sie nicht mit dem Anfang / Ende der Zeile übereinstimmen möchten.

Basic Regular Expression (BRE) (getestet auf GNU grep, GNU sed und vim):

/^[0-9]\+\.[0-9]\+\.[0-9]\+\.[0-9]\+$/

Erweiterter regulärer Ausdruck (ERE):

/^[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+$/

oder:

/^([0-9]+(\.|$)){4}/

Perl-kompatibler regulärer Ausdruck (PCRE) (getestet unter Perl 5.18):

/^\d+\.\d+\.\d+\.\d+$/

oder:

/^(\d+(\.|$)){4}/

Ruby (getestet auf Ruby 2.1):

Obwohl Ruby PCRE sein sollte, erlaubte es aus irgendeinem Grund diesen regulären Ausdruck, der von Perl 5.18 nicht zugelassen wurde:

/^(\d+[\.$]){4}/

Meine Tests für all diese sind hier online .

Alex Harvey
quelle
3

Dies ist etwas länger als einige andere, aber ich verwende diese Option, um IPv4-Adressen abzugleichen. Einfach ohne Kompromisse.

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

Die obigen Antworten sind gültig, aber was ist, wenn sich die IP-Adresse nicht am Ende der Zeile befindet und zwischen dem Text liegt? Dieser reguläre Ausdruck funktioniert sogar.

Code: '\b((([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])(\.)){3}([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5]))\b'

Eingabetextdatei:

ip address 0.0.0.0 asfasf
 sad sa 255.255.255.255 cvjnzx
zxckjzbxk  999.999.999.999 jshbczxcbx
sjaasbfj 192.168.0.1 asdkjaksb
oyo 123241.24121.1234.3423 yo
yo 0000.0000.0000.0000 y
aw1a.21asd2.21ad.21d2
yo 254.254.254.254 y0
172.24.1.210 asfjas
200.200.200.200
000.000.000.000
007.08.09.210
010.10.30.110

Ausgabetext:

0.0.0.0
255.255.255.255
192.168.0.1
254.254.254.254
172.24.1.210
200.200.200.200
Kushagra Gupta
quelle
1
Dies wurde negativ bewertet, bis ich darüber abstimmte. Ich habe genau das versucht (mehr Stunden als ich zugeben möchte). Es wird keine Linie erfasst, die mehr als ein Punkt-Quad auf einer Linie hat, aber für meinen Anwendungsfall kann ich damit leben. Dies ist eine ausgezeichnete Antwort, es braucht mehr Stimmen!
Katastrophe
3

'' 'Dieser Code funktioniert für mich und ist so einfach.

Hier habe ich den Wert von ip genommen und versuche ihn mit Regex abzugleichen.

ip="25.255.45.67"    

op=re.match('(\d+).(\d+).(\d+).(\d+)',ip)

if ((int(op.group(1))<=255) and (int(op.group(2))<=255) and int(op.group(3))<=255) and (int(op.group(4))<=255)):

print("valid ip")

else:

print("Not valid")

Die obige Bedingung prüft, ob der Wert für alle 4 Oktette 255 überschreitet, dann ist er nicht gültig. Bevor wir die Bedingung anwenden, müssen wir sie in eine Ganzzahl konvertieren, da sich der Wert in einer Zeichenfolge befindet.

Gruppe (0) druckt die übereinstimmende Ausgabe, während Gruppe (1) den ersten übereinstimmenden Wert druckt und hier "25" ist und so weiter. '' '

Shruti Lakkihal
quelle
Willkommen bei StackOverflow. Wenn Sie ein paar Worte darüber ausgeben könnten, warum Ihre Antwort das OP-Problem lösen sollte, wäre das großartig. Nur-Code-Antworten sind im Allgemeinen schlechte Antworten, da sie anderen Programmierern nicht helfen, zu verstehen, was sie falsch gemacht haben.
Davide Vitali
Verwenden Sie die richtige Einrückung in Ihrem Code, um ihn für die Benutzer lesbar zu machen
Syed Mehtab Hassan
2
/^(?:(25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)\.){3}(?1)$/m
Etienne Gautier
quelle
2

Für Zahlen von 0 bis 255 verwende ich diesen regulären Ausdruck:

(([0-9])|([1-9][0-9])|(1([0-9]{2}))|(2[0-4][0-9])|(25[0-5]))

Der obige reguläre Ausdruck stimmt mit der Ganzzahl von 0 bis 255 überein, nicht jedoch mit 256.

Für IPv4 verwende ich diesen regulären Ausdruck:

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

Es ist in dieser Struktur: ^(N)((\.(N)){3})$wobei N der reguläre Ausdruck ist, der verwendet wird, um die Zahl von 0 bis 255
abzugleichen. Dieser reguläre Ausdruck entspricht der IP wie folgt:

0.0.0.0
192.168.1.2

aber nicht die folgenden:

10.1.0.256
1.2.3.
127.0.1-2.3

Für IPv4 CIDR (Classless Inter-Domain Routing) verwende ich diesen regulären Ausdruck:

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

Es ist in dieser Struktur: ^(N)((\.(N)){3})\/M$wobei N der reguläre Ausdruck ist, der verwendet wird, um die Zahl von 0 bis 255 abzugleichen, und M der reguläre Ausdruck ist, der verwendet wird, um die Zahl von 0 bis 32
abzugleichen . Dieser reguläre Ausdruck entspricht dem CIDR wie folgt:

0.0.0.0/0
192.168.1.2/32

aber nicht die folgenden:

10.1.0.256/16
1.2.3./24
127.0.0.1/33

Und für die Liste der IPv4-CIDR, wie "10.0.0.0/16", "192.168.1.1/32"ich diesen regulären Ausdruck verwende:

^("(([0-9])|([1-9][0-9])|(1([0-9]{2}))|(2[0-4][0-9])|(25[0-5]))((\.(([0-9])|([1-9][0-9])|(1([0-9]{2}))|(2[0-4][0-9])|(25[0-5]))){3})\/(([0-9])|([12][0-9])|(3[0-2]))")((,([ ]*)("(([0-9])|([1-9][0-9])|(1([0-9]{2}))|(2[0-4][0-9])|(25[0-5]))((\.(([0-9])|([1-9][0-9])|(1([0-9]{2}))|(2[0-4][0-9])|(25[0-5]))){3})\/(([0-9])|([12][0-9])|(3[0-2]))"))*)$

Es ist in dieser Struktur: ^(“C”)((,([ ]*)(“C”))*)$wobei C der reguläre Ausdruck ist, der zur Übereinstimmung mit CIDR verwendet wird (wie 0.0.0.0/0).
Diese Regex entspricht der Liste der CIDR wie folgt:

“10.0.0.0/16”,”192.168.1.2/32”, “1.2.3.4/32”

aber nicht die folgenden:

“10.0.0.0/16” 192.168.1.2/32 “1.2.3.4/32”

Vielleicht wird es kürzer, aber für mich ist es für mich leicht zu verstehen.

Ich hoffe es hilft!

Congacon
quelle
Willkommen bei SO, wir freuen uns über Ihre Beiträge! Könnten Sie bitte etwas näher darauf eingehen, was die verschiedenen regulären Ausdrücke tun (insbesondere den letzten)?
B - rian
1

Ich habe es geschafft, aus allen anderen Antworten einen regulären Ausdruck zu erstellen.

(25[0-5]|2[0-4][0-9]|[1][0-9][0-9]|[1-9][0-9]|[0-9]?)(\.(25[0-5]|2[0-4][0-9]|[1][0-9][0-9]|[1-9][0-9]|[0-9]?)){3}
Vicky
quelle
Gemäß dem IEEE 802.x-Ethernet-Standard ist die IP-Validierung IP-Bereich 0.xxx >>> sollte nicht zulässig sein - ungültige IP. # 1.Der IP-Bereich von 1.xxx bis 126.xxx >>>> kann konfiguriert werden. # 2.IP-Bereich 127.xxx >>>> sollte nicht erlaubt sein - ungültige IP. # 3.IP-Bereich 128.xxx bis 223.xxx >> kann konfiguriert werden. Die bessere Vorgehensweise wird wie folgt vorgeschlagen: ^ (22 [0-3] | 2 [0-1] [0-9] | [1] [0-9] [0-9]? | [1-9 ] [0-9] | [1-9]) \. (25 [0-5] | 2 [0-4] [0-9] | [01]? [0-9] [0-9]? ) \. (25 [0-5] | 2 [0-4] [0-9] | [01]? [0-9] [0-9]?) \. (25 [0-4] | 2 [0-4] [0-9] | [01]? [0-9] [0-9]?) $
Yogesh Aggarwal
1

Mit Subnetzmaske:

^$|([01]?\\d\\d?|2[0-4]\\d|25[0-5])\\
.([01]?\\d\\d?|2[0-4]\\d|25[0-5])\\
.([01]?\\d\\d?|2[0-4]\\d|25[0-5])\\
.([01]?\\d\\d?|2[0-4]\\d|25[0-5])
((/([01]?\\d\\d?|2[0-4]\\d|25[0-5]))?)$
hsuk
quelle
1
(((25[0-5])|(2[0-4]\d)|(1\d{2})|(\d{1,2}))\.){3}(((25[0-5])|(2[0-4]\d)|(1\d{2})|(\d{1,2})))

Testen Sie, ob Übereinstimmungen im Text https://regex101.com/r/9CcMEN/2 gefunden wurden

Im Folgenden sind die Regeln aufgeführt, die die gültigen Kombinationen in jeder Nummer einer IP-Adresse definieren:

  • Beliebige ein- oder zweistellige Nummer.
  • Jede dreistellige Nummer, die mit beginnt 1.

  • Jede dreistellige Nummer, die mit beginnt, 2wenn die zweite Ziffer 0 durch ist 4.

  • Jede dreistellige Nummer, die mit beginnt, 25wenn die dritte Ziffer 0 durch ist 5.

Beginnen wir mit (((25[0-5])|(2[0-4]\d)|(1\d{2})|(\d{1,2}))\.)einer Reihe von vier verschachtelten Unterausdrücken, und wir werden sie in umgekehrter Reihenfolge betrachten. (\d{1,2})paßt auf jede ein- oder zweistellige Zahl oder Zahlen 0durch 99. (1\d{2})Entspricht einer dreistelligen Zahl, die mit 1( 1gefolgt von zwei Ziffern) beginnt , oder einer Zahl 100bis 199. (2[0-4]\d)passt Zahlen 200durch 249. (25[0-5])passt Zahlen 250durch 255. Jeder dieser Unterausdrücke ist in einem anderen Unterausdruck mit einem |Zwischenzeichen eingeschlossen (so dass einer der vier Unterausdrücke übereinstimmen muss, nicht alle). Nachdem der Zahlenbereich \.übereinstimmt ., und dann die gesamte Serie (alle Zahlenoptionen plus\.) wird in einen weiteren Unterausdruck eingeschlossen und dreimal mit wiederholt{3}. Schließlich wird der Nummernbereich wiederholt (diesmal ohne Nachlauf \.), um mit der endgültigen IP-Adressnummer übereinzustimmen. Durch Beschränken jeder der vier Zahlen auf Werte zwischen 0und 255kann dieses Muster tatsächlich mit gültigen IP-Adressen übereinstimmen und ungültige Adressen ablehnen.

Auszug aus: Ben Forta. "Reguläre Ausdrücke lernen."


Wenn weder am Anfang noch am Ende der IP-Adresse ein Zeichen gewünscht wird ^und $Metazeichen verwendet werden sollen.

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

Testen Sie, ob Übereinstimmungen im Text https://regex101.com/r/uAP31A/1 gefunden wurden

snr
quelle
1

Ich habe versucht, es etwas einfacher und kürzer zu machen.

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

Wenn Sie nach Java / Kotlin suchen:

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

Wenn jemand wissen will, wie es hier funktioniert, ist die Erklärung. Es ist wirklich so einfach. Probieren Sie es einfach aus: p:

 1. ^.....$: '^' is the starting and '$' is the ending.

 2. (): These are called a group. You can think of like "if" condition groups.

 3. |: 'Or' condition - as same as most of the programming languages.

 4. [01]?\d{1,2}: '[01]' indicates one of the number between 0 and 1. '?' means '[01]' is optional. '\d' is for any digit between 0-9 and '{1,2}' indicates the length can be between 1 and 2. So here the number can be 0-199.

 5. 2[0-4]\d: '2' is just plain 2. '[0-4]' means a number between 0 to 4. '\d' is for any digit between 0-9. So here the number can be 200-249.

 6. 25[0-5]: '25' is just plain 25. '[0-5]' means a number between 0 to 5. So here the number can be 250-255.

 7. \.: It's just plan '.'(dot) for separating the numbers.

 8. {3}: It means the exact 3 repetition of the previous group inside '()'.

 9. ([01]?\d{1,2}|2[0-4]\d|25[0-5]): Totally same as point 2-6

Mathematisch ist es wie:

(0-199 OR 200-249 OR 250-255).{Repeat exactly 3 times}(0-199 OR 200-249 OR 250-255)

Wie Sie normalerweise sehen können, ist dies das Muster für die IP-Adressen. Ich hoffe, es hilft, den regulären Ausdruck ein wenig zu verstehen. : p

Arhan Ashik
quelle
1

Ich habe versucht, es etwas einfacher und kürzer zu machen.

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

Wenn Sie nach Java / Kotlin suchen:

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

Wenn jemand wissen will, wie es hier funktioniert, ist die Erklärung. Es ist wirklich so einfach. Probieren Sie es einfach aus: p:

 1. ^.....$: '^' is the starting and '$' is the ending.

 2. (): These are called a group. You can think of like "if" condition groups.

 3. |: 'Or' condition - as same as most of the programming languages.

 4. [01]?\d{1,2}: '[01]' indicates one of the number between 0 and 1. '?' means '[01]' is optional. '\d' is for any digit between 0-9 and '{1,2}' indicates the length can be between 1 and 2. So here the number can be 0-199.

 5. 2[0-4]\d: '2' is just plain 2. '[0-4]' means a number between 0 to 4. '\d' is for any digit between 0-9. So here the number can be 200-249.

 6. 25[0-5]: '25' is just plain 25. '[0-5]' means a number between 0 to 5. So here the number can be 250-255.

 7. \.: It's just plan '.'(dot) for separating the numbers.

 8. {3}: It means the exact 3 repetition of the previous group inside '()'.

 9. ([01]?\d{1,2}|2[0-4]\d|25[0-5]): Totally same as point 2-6

Mathematisch ist es wie:

(0-199 OR 200-249 OR 250-255).{Repeat exactly 3 times}(0-199 OR 200-249 OR 250-255)

Wie Sie normalerweise sehen können, ist dies das Muster für die IP-Adressen. Ich hoffe, es hilft, den regulären Ausdruck ein wenig zu verstehen. : p

Arhan Ashik
quelle
0
    const char*ipv4_regexp = "\\b(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\."
    "(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\."
    "(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\."
    "(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\b";

Ich habe den regulären Ausdruck aus der JGsoft RegexBuddy-Bibliothek an die C-Sprache (regcomp / regexec) angepasst und festgestellt, dass er funktioniert, aber in einigen Betriebssystemen wie Linux gibt es ein kleines Problem. Dieser reguläre Ausdruck akzeptiert IPv4-Adressen wie 192.168.100.009, wobei 009 unter Linux als Oktalwert betrachtet wird, sodass die Adresse nicht die ist, die Sie gedacht haben. Ich habe diesen regulären Ausdruck wie folgt geändert:

    const char* ipv4_regex = "\\b(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\\."
           "(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\\."
           "(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\\."
           "(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\\b";

Wenn Sie diesen regulären Ausdruck jetzt verwenden, ist 192.168.100.009 keine gültige IPv4-Adresse, während 192.168.100.9 in Ordnung ist.

Ich habe auch einen regulären Ausdruck für die Multicast-Adresse geändert und es ist der folgende:

    const char* mcast_ipv4_regex = "\\b(22[4-9]|23[0-9])\\."
                        "(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\\."
                        "(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9]?)\\."
                        "(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\\b";

Ich denke, Sie müssen den regulären Ausdruck an die Sprache anpassen, die Sie für die Entwicklung Ihrer Anwendung verwenden

Ich habe ein Beispiel in Java gesetzt:

    package utility;

    import java.util.regex.Matcher;
    import java.util.regex.Pattern;

    public class NetworkUtility {

        private static String ipv4RegExp = "\\b(?:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d?)\\.){3}(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d?)\\b";

        private static String ipv4MulticastRegExp = "2(?:2[4-9]|3\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d?|0)){3}";

        public NetworkUtility() {

        }

        public static boolean isIpv4Address(String address) {
            Pattern pattern = Pattern.compile(ipv4RegExp);
            Matcher matcher = pattern.matcher(address);

            return matcher.matches();
        }

        public static boolean isIpv4MulticastAddress(String address) {
             Pattern pattern = Pattern.compile(ipv4MulticastRegExp);
             Matcher matcher = pattern.matcher(address);

             return matcher.matches();
        }
    }
Fabio Stafforte
quelle
0
-bash-3.2$ echo "191.191.191.39" | egrep 
  '(^|[^0-9])((2([6-9]|5[0-5]?|[0-4][0-9]?)?|1([0-9][0-9]?)?|[3-9][0-9]?|0)\.{3}
     (2([6-9]|5[0-5]?|[0-4][0-9]?)?|1([0-9][0-9]?)?|[3-9][0-9]?|0)($|[^0-9])'

>> 191.191.191.39

(Dies ist ein DFA, der dem gesamten Adressraum (einschließlich Broadcasts usw.) entspricht, und sonst nichts.

Jonathzen
quelle
0

Ich denke, dieser ist der kürzeste.

^(([01]?\d\d?|2[0-4]\d|25[0-5]).){3}([01]?\d\d?|2[0-4]\d|25[0-5])$
Altan Gokcek
quelle
0

Ich fand dieses Beispiel sehr nützlich, außerdem erlaubt es verschiedene IPv4-Notationen.

Beispielcode mit Python:

    def is_valid_ipv4(ip4):
    """Validates IPv4 addresses.
    """
    import re
    pattern = re.compile(r"""
        ^
        (?:
          # Dotted variants:
          (?:
            # Decimal 1-255 (no leading 0's)
            [3-9]\d?|2(?:5[0-5]|[0-4]?\d)?|1\d{0,2}
          |
            0x0*[0-9a-f]{1,2}  # Hexadecimal 0x0 - 0xFF (possible leading 0's)
          |
            0+[1-3]?[0-7]{0,2} # Octal 0 - 0377 (possible leading 0's)
          )
          (?:                  # Repeat 0-3 times, separated by a dot
            \.
            (?:
              [3-9]\d?|2(?:5[0-5]|[0-4]?\d)?|1\d{0,2}
            |
              0x0*[0-9a-f]{1,2}
            |
              0+[1-3]?[0-7]{0,2}
            )
          ){0,3}
        |
          0x0*[0-9a-f]{1,8}    # Hexadecimal notation, 0x0 - 0xffffffff
        |
          0+[0-3]?[0-7]{0,10}  # Octal notation, 0 - 037777777777
        |
          # Decimal notation, 1-4294967295:
          429496729[0-5]|42949672[0-8]\d|4294967[01]\d\d|429496[0-6]\d{3}|
          42949[0-5]\d{4}|4294[0-8]\d{5}|429[0-3]\d{6}|42[0-8]\d{7}|
          4[01]\d{8}|[1-3]\d{0,9}|[4-9]\d{0,8}
        )
        $
    """, re.VERBOSE | re.IGNORECASE)
    return pattern.match(ip4) <> None
Internety
quelle
0
((\.|^)(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]?|0$)){4}

Diese Regex akzeptiert nicht 08.8.8.8 oder 8.08.8.8 oder 8.8.08.8 oder 8.8.8.08

Sudistack
quelle
Dieser verfehlt zum Beispiel 127.0.0.1 und 0.0.0.0
Anneb
^ ((\. | ^) (25 [0-5] | 2 [0-4] [0-9] | 1 [0-9] [0-9] | [1-9] [0-9] | [0-9] | 0)) ((\. | ^) (25 [0-5] | 2 [0-4] [0-9] | 1 [0-9] [0-9] | [1-9] [0-9]? | 0)) {2}. ((25 [0-5] | 2 [0-4] [0-9] | 1 [0-9] [0- 9] | [1-9] [0-9]? | 0) $)
Sudistack
1
Es ist richtig, führende Nullen gemäß der Spezifikation abzulehnen.
John Haugeland
0

Findet eine gültige IP-Adresse, solange die IP um ein anderes Zeichen als Ziffern (hinter oder vor der IP) gewickelt ist. 4 Rückreferenzen erstellt: $ + {first}. $ + {Second}. $ + {Third}. $ + {Fourth}

Find String:
#any valid IP address
(?<IP>(?<![\d])(?<first>(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5]))[\.](?<second>(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5]))[\.](?<third>(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5]))[\.](?<forth>(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5]))(?![\d]))
#only valid private IP address RFC1918
(?<IP>(?<![\d])(:?(:?(?<first>10)[\.](?<second>(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5])))|(:?(?<first>172)[\.](?<second>(:?1[6-9])|(:?2[0-9])|(:?3[0-1])))|(:?(?<first>192)[\.](?<second>168)))[\.](?<third>(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5]))[\.](?<forth>(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5]))(?![\d]))

Notepad++ Replace String Option 1: Replaces the whole IP (NO Change):
$+{IP}

Notepad++ Replace String Option 2: Replaces the whole IP octect by octect (NO Change)
$+{first}.$+{second}.$+{third}.$+{forth}

Notepad++ Replace String Option 3: Replaces the whole IP octect by octect (replace 3rd octect value with 0)
$+{first}.$+{second}.0.$+{forth}
NOTE: The above will match any valid IP including 255.255.255.255 for example and change it to 255.255.0.255 which is wrong and not very useful of course.

Ersetzen Sie einen Teil jedes Oktekts durch einen tatsächlichen Wert. Sie können jedoch einen eigenen Such- und Ersetzungswert erstellen, der zum Ändern von IPs in Textdateien nützlich ist:

for example replace the first octect group of the original Find regex above:
(?<first>(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5]))
with
(?<first>10)

and
(?<second>(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5]))
with
(?<second>216)
and you are now matching addresses starting with first octect 192 only

Find on notepad++:
(?<IP>(?<![\d])(?<first>10)[\.](?<second>216)[\.](?<third>(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5]))[\.](?<forth>(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5]))(?![\d]))

Sie können das Ersetzen weiterhin mithilfe von Back-Referece-Gruppen genauso durchführen wie zuvor.

Sie können sich ein Bild davon machen, wie das oben Gesagte übereinstimmt:

cat ipv4_validation_test.txt
Full Match:
0.0.0.1
12.108.1.34
192.168.1.1
10.249.24.212
10.216.1.212
192.168.1.255
255.255.255.255
0.0.0.0


Partial Match (IP Extraction from line)
30.168.1.0.1
-1.2.3.4
sfds10.216.24.23kgfd
da11.15.112.255adfdsfds
sfds10.216.24.23kgfd


NO Match
1.1.1.01
3...3
127.1.
192.168.1..
192.168.1.256
da11.15.112.2554adfdsfds
da311.15.112.255adfdsfds

Mit grep können Sie die folgenden Ergebnisse sehen:

From grep:
grep -oP '(?<IP>(?<![\d])(?<first>(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5]))[\.](?<second>(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5]))[\.](?<third>(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5]))[\.](?<forth>(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5]))(?![\d]))' ipv4_validation_test.txt
0.0.0.1
12.108.1.34
192.168.1.1
10.249.24.212
10.216.1.212
192.168.1.255
255.255.255.255
0.0.0.0
30.168.1.0
1.2.3.4
10.216.24.23
11.15.112.255
10.216.24.23


grep -P '(?<IP>(?<![\d])(?<first>(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5]))[\.](?<second>(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5]))[\.](?<third>(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5]))[\.](?<forth>(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5]))(?![\d]))' ipv4_validation_test.txt
0.0.0.1
12.108.1.34
192.168.1.1
10.249.24.212
10.216.1.212
192.168.1.255
255.255.255.255
0.0.0.0
30.168.1.0.1
-1.2.3.4
sfds10.216.24.23kgfd
da11.15.112.255adfdsfds
sfds10.216.24.23kgfd


#matching ip addresses starting with 10.216
grep -oP '(?<IP>(?<![\d])(?<first>10)[\.](?<second>216)[\.](?<third>(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5]))[\.](?<forth>(:?\d)|(:?[1-9]\d)|(:?1\d{2})|(:?2[0-4]\d)|(:?25[0-5]))(?![\d]))' ipv4_validation_test.txt
10.216.1.212
10.216.24.23
10.216.24.23
rda
quelle
0

IPv4-Adresse ist eine sehr komplizierte Sache.

Hinweis : Einrückung und Verkleidung dienen nur zur Veranschaulichung und sind im realen RegEx nicht vorhanden.

\b(
  ((
    (2(5[0-5]|[0-4][0-9])|1[0-9]{2}|[1-9]?[0-9])
  |
    0[Xx]0*[0-9A-Fa-f]{1,2}
  |
    0+[1-3]?[0-9]{1,2}
  )\.){1,3}
  (
    (2(5[0-5]|[0-4][0-9])|1[0-9]{2}|[1-9]?[0-9])
  |
    0[Xx]0*[0-9A-Fa-f]{1,2}
  |
    0+[1-3]?[0-9]{1,2}
  )
|
  (
    [1-3][0-9]{1,9}
  |
    [1-9][0-9]{,8}
  |
    (4([0-1][0-9]{8}
      |2([0-8][0-9]{7}
        |9([0-3][0-9]{6}
          |4([0-8][0-9]{5}
            |9([0-5][0-9]{4}
              |6([0-6][0-9]{3}
                |7([0-1][0-9]{2}
                  |2([0-8][0-9]{1}
                    |9([0-5]
    ))))))))))
  )
|
  0[Xx]0*[0-9A-Fa-f]{1,8}
|
  0+[1-3]?[0-7]{,10}
)\b

Diese IPv4-Adressen werden von der oben genannten RegEx validiert.

127.0.0.1
2130706433
0x7F000001
017700000001
0x7F.0.0.01 # Mixed hex/dec/oct
000000000017700000001 # Have as many leading zeros as you want
0x0000000000007F000001 # Same as above
127.1
127.0.1

Diese werden abgelehnt.

256.0.0.1
192.168.1.099 # 099 is not a valid number
4294967296 # UINT32_MAX + 1
0x100000000
020000000000
iBug
quelle
0

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


Oben ist Regex für die IP-Adresse wie: 221.234.000.112 auch für 221.234.0.112, 221.24.03.112, 221.234.0.1


Sie können sich alle Arten von Adressen wie oben vorstellen

Ram Sharma
quelle
0

Ich würde PCRE und das defineSchlüsselwort verwenden:

/^
 ((?&byte))\.((?&byte))\.((?&byte))\.((?&byte))$
 (?(DEFINE)
     (?<byte>25[0-5]|2[0-4]\d|[01]?\d\d?))
/gmx

Demo: https://regex101.com/r/IB7j48/2

Der Grund dafür ist, dass das (25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)Muster nicht viermal wiederholt wird . Andere Lösungen wie die folgende funktionieren gut, erfassen jedoch nicht jede Gruppe, wie dies von vielen gewünscht wird.

/^((\d+?)(\.|$)){4}/ 

Die einzige andere Möglichkeit, 4 Erfassungsgruppen zu haben, besteht darin, das Muster viermal zu wiederholen:

/^(?<one>\d+)\.(?<two>\d+)\.(?<three>\d+)\.(?<four>\d+)$/

Das Erfassen eines IPv4 in Perl ist daher sehr einfach

$ echo "Hey this is my IP address 138.131.254.8, bye!" | \
  perl -ne 'print "[$1, $2, $3, $4]" if \
    /\b((?&byte))\.((?&byte))\.((?&byte))\.((?&byte))
     (?(DEFINE)
        \b(?<byte>25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?))
    /x'

[138, 131, 254, 8]
nowox
quelle
0

Das präziseste, einfachste und kompakteste IPv4-Regexp, das ich mir vorstellen kann, ist

^(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)\.(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)$

Aber was ist mit der Leistung / Effizienz von ... Entschuldigung, ich weiß nicht, wen interessiert das?

Fuweichin
quelle
0

Versuche dies:

\b(([1-9]|[1-9][0-9]|1[0-9][0-9]|2[0-5][0-5])\.([1-9]|[1-9][0-9]|1[0-9][0-9]|2[0-5][0-5])\.([1-9]|[1-9][0-9]|1[0-9][0-9]|2[0-5][0-5])\.(2[0-5][0-5]|1[0-9][0-9]|[1-9][0-9]|[1-9]))\b
AAP
quelle
0
ip address can be from 0.0.0.0 to 255.255.255.255

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

(0|1)?[0-9][0-9]? - checking value from 0 to 199
2[0-4][0-9]- checking value from 200 to 249
25[0-5]- checking value from 250 to 255
[.] --> represent verify . character 
{3} --> will match exactly 3
$ --> end of string
Deepak_Mahalingam
quelle
0

Es folgt der Regex-Ausdruck zur Überprüfung der IP-Adresse.

^((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]?)$
Dilip Paudel
quelle
0

Einfacher Weg

((25[0-5]|2[0-4][0-9]|[1][0-9][0-9]|[1-9][0-9]{0,1})\.){3}(25[0-5]|2[0-4][0-9]|[1][0-9][0-9]|[1-9][0-9]{0,1})

Demo

BabiBN
quelle