regex - IPv4-adressen valideren met regexp

Ik heb geprobeerd een efficiënte regex voor IPv4-validatie te krijgen, maar zonder veel geluk. Het leek op een gegeven moment dat ik het gehad had met (25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?(\.|$)){4}, maar het levert vreemde resultaten op:

$ 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

Ik heb gezocht om te zien of dit al is gevraagd en beantwoord, maar andere antwoorden lijken eenvoudigweg te laten zien hoe je 4 groepen van 1-3 nummers kunt bepalen, of werken niet voor mij.

Antwoord 1, autoriteit 100%

Je hebt al een werkend antwoord, maar voor het geval je benieuwd bent wat er mis was met je oorspronkelijke aanpak, het antwoord is dat je haakjes rond je afwisseling nodig hebt, anders de (\.|$)is alleen vereist als het aantal kleiner is dan 200.

'\b((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)(\.|$)){4}\b'
    ^                                    ^

Antwoord 2, autoriteit 80%

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

Accepteren:

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!

Weigeren:

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

Probeer online met unit tests: https://www.debuggex.com/r/- EDZOqxTxhiTncN6/1

Antwoord 3, autoriteit 62%

Nieuwste, kortste, minst leesbare versie (49 tekens)

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

De [0-9]blokken kunnen op 2 plaatsen worden vervangen door \d– maakt het een beetje minder leesbaar, maar zeker korter.

Nog nieuwere, nog kortere, op één na minst leesbare versie (55 tekens)

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

Deze versie zoekt naar het geval 250-5, daarna ORS slim alle mogelijke gevallen voor 200-249100-19910-99gevallen. Merk op dat het |)-gedeelte geen fout is, maar in feite het laatste geval is voor het 0-9-bereik. Ik heb ook het ?:niet-vastleggende groepsgedeelte weggelaten, omdat we niet echt om de vastgelegde items geven, ze zouden hoe dan ook niet worden vastgelegd als we geen volledige overeenkomst hadden in de eerste plaats.

Oude en kortere versie (minder leesbaar) (63 tekens)

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

Oudere (leesbare) versie (70 tekens)

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

Het gebruikt de negatieve lookahead (?!)om het geval te verwijderen waarin het ip zou kunnen eindigen met een .

oudste antwoord (115 tekens )

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

Ik denk dat dit de meest accurate en strikte regex is, het accepteert dingen niet als 000.021.01.0.Het lijkt erop dat de meeste andere antwoorden hier doen en vereisen extra regex om gevallen met dat te verwerken één – dwz 0startnummers en een IP die eindigt met een .

Antwoord 4, Autoriteit 12%

IPv4-adres (nauwkeurige opname)
Komt overeen met 0.0.0.0 tot 255.255.255.255, maar legt geen ongeldige adressen vast zoals 1.1.000.1
Gebruik deze regex die overeenkomt met IP-nummers met nauwkeurigheid.
Elk van de 4 nummers wordt opgeslagen in een vastleggroep, zodat u toegang hebt tot ze voor verdere verwerking.

\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

Genomen uit JGSOFT RGEXBUDDY-bibliotheek

EDIT: deze (\.|$)deel lijkt raar

Antwoord 5, Autoriteit 7%

Ik was op zoek naar iets dat vergelijkbaar is voor IPv4-adressen – een regex die ook veel gebruikte particuliere IP-adressen is gewaardeerd van gevalideerd (192.168.xy, 10xyz, 172.16.xy), dus gebruikte negatieve look-tonen om dit te bereiken:

(?!(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}

(deze moeten op één lijn zijn, opeenvolgend voor leesbaarheidsdoeleinden op 3 afzonderlijke regels)

Debuggex-demo

Het is misschien niet geoptimaliseerd voor snelheid, maar werkt goed als je alleen naar ‘echte’ internetadressen zoekt.

Dingen die zullen (en zouden moeten) mislukken:

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

IP’s die zullen (en zouden moeten) werken:

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)

Geleverd voor het geval iemand anders ‘Internet IP-adressen exclusief de algemene privé-adressen’ wil valideren

Antwoord 6, autoriteit 6%

Ik denk dat veel mensen die dit bericht lezen, op zoek zullen zijn naar eenvoudigere reguliere expressies, zelfs als ze overeenkomen met een aantal technisch ongeldige IP-adressen. (En, zoals elders opgemerkt, regex is waarschijnlijk toch niet de juiste tool om een IP-adres correct te valideren.)

Verwijder ^en vervang, indien van toepassing, $door \b, als u niet wilt dat het begin/einde van de lijn.

Basic Regular Expression (BRE) (getest op GNU grep, GNU sed en vim):

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

Extended regelmatige expressie (ere):

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

of:

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

perl-compatibele reguliere expressie (pcre) (getest op perl 5.18):

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

of:

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

Ruby (getest op Ruby 2.1):

Hoewel verondersteld om PCE, RUBY te zijn om welke reden dan ook toegestaan dit regex niet toegestaan door PERL 5.18:

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

Mijn tests voor al deze zijn online hier .

Antwoord 7, Autoriteit 3%

Dit is iets langer dan sommigen, maar dit is wat ik gebruik om de IPv4-adressen te matchen. Eenvoudig zonder compromissen.

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

Antwoord 8, Autoriteit 3%

bovenstaande antwoorden zijn geldig, maar wat als het IP-adres niet aan het einde van de regel staat en tussen tekst is. Deze regex zal daar zelfs aan werken.

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'

Tekstbestand invoeren:

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

uitvoertekst:

0.0.0.0
255.255.255.255
192.168.0.1
254.254.254.254
172.24.1.210
200.200.200.200

Antwoord 9, autoriteit 3%

”’
Deze code werkt voor mij, en zo simpel is het.

Hier heb ik de waarde van ip genomen en ik probeer deze te matchen met regex.

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

Bovenstaande voorwaarde controleert of de waarde groter is dan 255 voor alle 4 octetten, dan is deze niet geldig. Maar voordat we de voorwaarde toepassen, moeten we ze converteren naar een geheel getal, aangezien de waarde in een string staat.

groep(0) drukt de overeenkomende uitvoer af, terwijl groep(1) de eerste overeenkomende waarde afdrukt en hier is het “25” enzovoort.
”’

Antwoord 10, autoriteit 2%

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

Antwoord 11, autoriteit 2%

Voor nummer van 0 tot 255 gebruik ik deze regex:

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

Bovenstaande regex komt overeen met geheel getal van 0 tot 255, maar niet overeenkomen met 256.

Dus voor IPv4 Ik gebruik dit regex:

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

Het is in deze structuur: ^(N)((\.(N)){3})$waarbij n de regex is die wordt gebruikt om overeen te komen met nummer van 0 tot 255.
Deze regex komt overeen met IP zoals hieronder:

0.0.0.0
192.168.1.2

Maar niet die hieronder:

10.1.0.256
1.2.3.
127.0.1-2.3

voor IPv4 CIDR (klasloze inter-domein routing) Ik gebruik dit regex:

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

Het is in deze structuur: ^(N)((\.(N)){3})\/M$waarbij n de regex is die wordt gebruikt om overeen te komen met nummer van 0 tot 255, en M is de regex die wordt gebruikt om overeen te komen met nummer van 0 tot 32.
Deze regex komt overeen met CIDR zoals hieronder:

0.0.0.0/0
192.168.1.2/32

Maar niet die hieronder:

10.1.0.256/16
1.2.3./24
127.0.0.1/33

en voor lijst met IPv4 CIDR zoals "10.0.0.0/16", "192.168.1.1/32"I GEBRUIK DIT REX:

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

Het is in deze structuur: ^(“C”)((,([ ]*)(“C”))*)$waarbij C de regex is die wordt gebruikt om CIDR te matchen (zoals 0.0.0.0/0).
Deze regex komt overeen met de lijst met CIDR zoals hieronder:

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

maar niet die hieronder:

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

Misschien wordt het korter, maar voor mij is het gemakkelijk te begrijpen, zo fijn voor mij.

Hopelijk helpt het!

Antwoord 12, autoriteit 2%

Hier is een betere met bijgevoegde/mislukte IP’s

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

Accepteert

127.0.0.1
192.168.1.1
192.168.1.255
255.255.255.255
10.1.1.1
0.0.0.0

Weigert

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

Antwoord 13

Ik heb van alle andere antwoorden een regex kunnen maken.

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

Antwoord 14

Met subnetmasker:

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

Antwoord 15

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

Test om overeenkomsten in tekst te vinden,
https://regex101.com/r/9CcMEN/2

Hier volgen de regels die de geldige combinaties in elk nummer van een IP-adres definiëren:

Elk nummer van één of twee cijfers.
Elk driecijferig nummer dat begint met 1.
Elk driecijferig nummer dat begint met 2als het tweede cijfer 0is
via 4.
Elk getal van drie cijfers dat begint met 25als het derde cijfer 0is
via 5.

Laten we beginnen met (((25[0-5])|(2[0-4]\d)|(1\d{2})|(\d{1,2}))\.), een set van vier geneste subexpressies, en we zullen ze in omgekeerde volgorde bekijken. (\d{1,2})komt overeen met elk een- of tweecijferig nummer of getallen 0tot en met 99. (1\d{2})komt overeen met elk driecijferig nummer dat begint met 1(1gevolgd door twee willekeurige cijfers), of cijfers 100tot en met 199. (2[0-4]\d)komt overeen met de nummers 200tot en met 249. (25[0-5])komt overeen met de nummers 250tot en met 255. Elk van deze subexpressies is ingesloten in een andere subexpressie met een |tussen elk (zodat een van de vier subexpressies moet overeenkomen, niet alle). Na het bereik van getallen komt \.om overeen te komen met ., en dan wordt de hele reeks (alle nummeropties plus \.) ingesloten in nog een andere subexpressie en drie keer herhaald met {3}. Ten slotte wordt de reeks getallen herhaald (deze keer zonder de achterliggende \.) om overeen te komen met het uiteindelijke IP-adresnummer. Door elk van de vier getallen te beperken tot waarden tussen 0en 255, kan dit patroon inderdaad overeenkomen met geldige IP-adressen en ongeldige adressen weigeren.

Uittreksel van: Ben Forta. “Reguliere expressies leren.”

Als noch een teken aan het begin van het IP-adres noch aan het einde gewenst is, moeten respectievelijk ^en $metatekens worden gebruikt.

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

Test om overeenkomsten in tekst te vinden,
https://regex101.com/R/uap31A/1

Antwoord 16

Ik probeerde het een beetje eenvoudiger en korter te maken.

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

Als u op zoek bent naar JAVA / KOTLIN:

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

Als iemand wil weten hoe het hier werkt, is de uitleg. Het is echt zo eenvoudig. Geef het gewoon eens: 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 is het als:

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

Dus, zoals je normaal kunt zien, is dit het patroon voor de IP-adressen. Ik hoop dat het helpt om de reguliere expressie een beetje te begrijpen. :p

Antwoord 17

Ik heb geprobeerd het wat eenvoudiger en korter te maken.

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

Als u op zoek bent naar java/kotlin:

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

Als iemand wil weten hoe het werkt, staat hier de uitleg. Het is echt zo simpel. Probeer het gewoon eens :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

Wiskundig gezien is het zoiets als:

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

Dus, zoals je normaal kunt zien, is dit het patroon voor de IP-adressen. Ik hoop dat het helpt om de reguliere expressie een beetje te begrijpen. :p

Antwoord 18

   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";

Ik heb de reguliere expressie uit de JGsoft RegexBuddy-bibliotheek aangepast naar de C-taal (regcomp/regexec) en ik ontdekte dat het werkt, maar er is een klein probleem in sommige besturingssystemen zoals Linux.
Die reguliere expressie accepteert een ipv4-adres zoals 192.168.100.009, waarbij 009 in Linux als een octale waarde wordt beschouwd, dus het adres is niet het adres dat je dacht.
Ik heb die reguliere expressie als volgt gewijzigd:

   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";

het gebruik van die reguliere expressie nu 192.168.100.009 is geen geldig ipv4-adres terwijl 192.168.100.9 ok is.

Ik heb ook een reguliere expressie voor multicast-adres gewijzigd en deze is de volgende:

   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";

Ik denk dat je de reguliere expressie moet aanpassen aan de taal die je gebruikt om je applicatie te ontwikkelen

Ik heb een voorbeeld in java gezet:

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

Antwoord 19

-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

(Dit is een DFA die overeenkomt met de volledige addr-ruimte (inclusief uitzendingen, enz.) en niets anders.

Antwoord 20

Ik denk dat deze de kortste is.

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

Antwoord 21

Ik vond dit monster erg handig, bovendien maakt het verschillende IPv4-notaties mogelijk.

Voorbeeldcode met 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

Antwoord 22

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

Deze regex accepteert niet
08.8.8.8 of 8.08.8.8 of 8.8.08.8 of 8.8.8.08

Antwoord 23

Vindt een geldig IP-adres zolang het IP-adres rond een ander teken dan cijfers is gewikkeld (achter of vóór het IP). 4 Backreferenties aangemaakt: $+{first}.$+{second}.$+{third}.$+{forth}

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.

Een deel van elk octect vervangen door een werkelijke waarde, maar u kunt uw eigen zoek-en-vervanging maken, wat echt handig is om IP’s in tekstbestanden aan te passen:

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

U kunt nog steeds vervanging uitvoeren met behulp van back-ref-referentiegroepen op exact dezelfde manier als voorheen.

U kunt een idee krijgen van hoe het bovenstaande hieronder is gekoppeld:

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

GREP gebruiken U kunt de volgende resultaten zien:

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

Antwoord 24

IPv4-adres is een heel ingewikkeld iets.

Opmerking: Inspringing en voering zijn alleen ter illustratie en bestaan niet in de echte RegEx.

\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

Deze IPv4-adressen worden gevalideerd door de bovenstaande RegEx.

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

Deze worden afgewezen.

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

Antwoord 25

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

Hierboven staat de regex voor het ip-adres, zoals:
221.234.000.112
ook voor 221.234.0.112, 221.24.03.112, 221.234.0.1

U kunt zich alle soorten adressen voorstellen zoals hierboven

Antwoord 26

Ik zou PCRE gebruiken en het trefwoord define:

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

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

De reden hiervan is om te voorkomen dat de (25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)patroon vier keer. Andere oplossingen, zoals de onderstaande, werken goed, maar het is niet geschikt voor elke groep, zoals velen zouden vragen.

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

De enige andere manier om 4 capture-groepen te hebben, is door het patroon vier keer te herhalen:

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

Het vastleggen van een IPv4 in PERL is daarom zeer eenvoudig

$ 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]

Antwoord 27

De meest precieze, rechtlijnige en compacte IPv4 Regexp Ik kan me voorstellen

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

Maar hoe zit het met de prestaties / efficiëntie van … Sorry, ik weet het niet, Who cares?

Antwoord 28

Probeer dit:

\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

Antwoord 29

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

ANTWOORD 30

Hieronder volgt de regex-expressie om het IP-adres te valideren.

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

IPv4-adressen valideren met regexp