Convalida degli indirizzi IPv4 con regexp

Ho provato a ottenere una regex efficiente per la convalida IPv4, ma senza molta fortuna. A un certo punto sembrava che ce l'avessi fatta (25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?(\.|$)){4}, ma produce alcuni strani risultati:

$ 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

Ho fatto una ricerca per vedere se questo era già stato chiesto e risposto, ma altre risposte sembrano mostrare semplicemente come determinare 4 gruppi di 1-3 numeri, o non funzionano per me.

Hai già una risposta funzionante, ma nel caso fossi curioso di sapere cosa c'era di sbagliato nel tuo approccio originale, la risposta è che hai bisogno di parentesi attorno alla tua alternanza altrimenti (\.|$)è richiesta solo se il numero è inferiore a 200.

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

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

Accetta :

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!

Rifiuta :

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

Prova online con unit test: https://www.debuggex.com/r/-EDZOqxTxhiTncN6/1

Versione più recente, più breve, meno leggibile ( 55 caratteri )

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

Questa versione cerca il caso 250-5, dopodiché esegue in modo intelligente tutti i casi possibili per i 200-249 100-199 10-99casi. Si noti che la |)parte non è un errore, ma in realtà esegue l'OR dell'ultimo caso per l'intervallo 0-9. Ho anche omesso la ?:parte del gruppo non catturante poiché non ci interessa davvero degli oggetti catturati, non verrebbero catturati in entrambi i casi se non avessimo una corrispondenza completa in primo luogo.

Versione vecchia e più breve (meno leggibile) ( 63 caratteri )

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

Versione precedente (leggibile) ( 70 caratteri )

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

Utilizza il lookahead negativo (?!)per rimuovere il caso in cui l'ip potrebbe terminare con un.

Risposta più vecchia ( 115 caratteri )

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

Penso che questa sia la regex più accurata e rigorosa, non accetta cose come 000.021.01.0.sembra che la maggior parte delle altre risposte qui lo faccia e richiede un'espressione regolare aggiuntiva per rifiutare casi simili a quello - cioè 0numeri iniziali e un ip che termina con.

Indirizzo IPv4 (acquisizione accurata) Corrisponde a 0.0.0.0 fino a 255.255.255.255, ma acquisisce indirizzi non validi come 1.1.000.1 Utilizza questa regex per abbinare i numeri IP con precisione. Ciascuno dei 4 numeri viene memorizzato in un gruppo di acquisizione, quindi è possibile accedervi per ulteriori elaborazioni.

\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

tratto dalla libreria JGsoft RegexBuddy

Modifica: questa (\.|$)parte sembra strana

Ero alla ricerca di qualcosa di simile per gli indirizzi IPv4: un'espressione regolare che impediva anche la convalida degli indirizzi IP privati ​​comunemente usati (192.168.xy, 10.xyz, 172.16.xy), quindi utilizzava uno sguardo negativo per ottenere questo risultato:

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

(Questi dovrebbero essere su una riga ovviamente, formattati per scopi di leggibilità su 3 righe separate)

Debuggex Demo

Potrebbe non essere ottimizzato per la velocità, ma funziona bene quando si cercano solo indirizzi Internet "reali".

Cose che (e dovrebbero) fallire:

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 che funzioneranno (e dovrebbero):

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)

Fornito nel caso in cui qualcun altro stia cercando la convalida di "indirizzi IP Internet esclusi gli indirizzi privati ​​comuni"

Penso che molte persone che leggono questo post cercheranno espressioni regolari più semplici, anche se corrispondono ad indirizzi IP tecnicamente non validi. (E, come notato altrove, regex probabilmente non è lo strumento giusto per convalidare correttamente un indirizzo IP comunque.)

Rimuovere ^e, se applicabile, sostituire $con \b, se non si desidera far corrispondere l'inizio / fine della riga.

Basic Regular Expression (BRE) (testato su GNU grep, GNU sed e vim):

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

Espressione regolare estesa (ERE):

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

o:

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

Espressione regolare (PCRE) compatibile con Perl (testata su Perl 5.18):

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

o:

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

Ruby (testato su Ruby 2.1):

Anche se dovrebbe essere PCRE, Ruby per qualsiasi motivo ha consentito a questa regex non consentita da Perl 5.18:

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

I miei test per tutti questi sono online qui .

Questo è un po 'più lungo di altri, ma è quello che uso per abbinare gli indirizzi IPv4. Semplice senza compromessi.

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

Le risposte sopra sono valide, ma cosa succede se l'indirizzo IP non è alla fine della riga e si trova tra il testo ... Questa regex funzionerà anche su questo.

codice: '\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'

file di testo di input:

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

testo di output:

0.0.0.0
255.255.255.255
192.168.0.1
254.254.254.254
172.24.1.210
200.200.200.200

'' 'Questo codice funziona per me ed è così semplice.

Qui ho preso il valore di ip e sto cercando di abbinarlo a 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")

La condizione di cui sopra controlla se il valore supera 255 per tutti i 4 ottetti, quindi non è valido. Ma prima di applicare la condizione dobbiamo convertirli in interi poiché il valore è in una stringa.

group (0) stampa l'output corrispondente, mentre group (1) stampa il primo valore abbinato e qui è "25" e così via. '' '

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

Per il numero da 0 a 255 utilizzo questa regex:

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

L'espressione regolare sopra corrisponderà al numero intero compreso tra 0 e 255, ma non corrisponderà a 256.

Quindi per IPv4 uso questa 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})$

È in questa struttura: ^(N)((\.(N)){3})$dove N è la regex usata per abbinare il numero da 0 a 255.
Questa regex corrisponderà a IP come di seguito:

0.0.0.0
192.168.1.2

ma non quelli di seguito:

10.1.0.256
1.2.3.
127.0.1-2.3

Per IPv4 CIDR (Classless Inter-Domain Routing) utilizzo questa 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]))$

È in questa struttura: ^(N)((\.(N)){3})\/M$dove N è la regex utilizzata per abbinare il numero da 0 a 255 e M è la regex utilizzata per abbinare il numero da 0 a 32.
Questa regex corrisponderà a CIDR come di seguito:

0.0.0.0/0
192.168.1.2/32

ma non quelli di seguito:

10.1.0.256/16
1.2.3./24
127.0.0.1/33

E per l'elenco di CIDR IPv4 come "10.0.0.0/16", "192.168.1.1/32"io uso questa 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]))")((,([ ]*)("(([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]))"))*)$

È in questa struttura: ^(“C”)((,([ ]*)(“C”))*)$dove C è la regex usata per abbinare CIDR (come 0.0.0.0/0).
Questa regex corrisponderà all'elenco di CIDR come di seguito:

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

ma non quelli di seguito:

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

Forse potrebbe accorciarsi ma per me è facile da capire così bene da me.

Spero che sia d'aiuto!

Sono riuscito a costruire una regex da tutte le altre risposte.

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

Con maschera di sottorete:

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

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

Prova per trovare corrispondenze nel testo, https://regex101.com/r/9CcMEN/2

Di seguito sono riportate le regole che definiscono le combinazioni valide in ogni numero di un indirizzo IP:

• Qualsiasi numero a una o due cifre.

• Qualsiasi numero di tre cifre che inizia con 1.

• Qualsiasi numero di tre cifre che inizia con 2se la seconda cifra è 0 fino a 4.

• Qualsiasi numero di tre cifre che inizia con 25se la terza cifra è 0 fino a 5.

Cominciamo con (((25[0-5])|(2[0-4]\d)|(1\d{2})|(\d{1,2}))\.)un insieme di quattro sottoespressioni annidate e le esamineremo in ordine inverso. (\d{1,2})corrisponde a qualsiasi numero o numero di una o due cifre 0fino a 99. (1\d{2})corrisponde a qualsiasi numero di tre cifre che inizia con 1( 1seguito da due cifre qualsiasi) o numeri 100fino a 199. (2[0-4]\d)corrisponde ai numeri 200fino a 249. (25[0-5])corrisponde ai numeri 250fino a 255. Ciascuna di queste sottoespressioni è racchiusa all'interno di un'altra sottoespressione con una |tra ciascuna (in modo che una delle quattro sottoespressioni debba corrispondere, non tutte). Dopo che l'intervallo di numeri \.corrisponde ) viene racchiuso in un'altra sottoespressione e ripetuto tre volte usando. , quindi l'intera serie (tutte le opzioni numeriche più\.{3}. Infine, l'intervallo di numeri viene ripetuto (questa volta senza il finale \.) per abbinare il numero dell'indirizzo IP finale. Limitando ciascuno dei quattro numeri a valori compresi tra 0e 255, questo modello può effettivamente abbinare indirizzi IP validi e rifiutare indirizzi non validi.

Estratto da: Ben Forta. "Imparare le espressioni regolari".

Se non si desidera né un carattere all'inizio dell'indirizzo IP né alla fine, ^e $devono essere utilizzati rispettivamente i metacaratteri.

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

Prova per trovare corrispondenze nel testo, https://regex101.com/r/uAP31A/1

Ho provato a renderlo un po 'più semplice e più breve.

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

Se stai cercando 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])$

Se qualcuno vuole sapere come funziona ecco la spiegazione. È davvero così semplice. Provalo: 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

Matematicamente è come:

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

Quindi, come puoi vedere normalmente, questo è il modello per gli indirizzi IP. Spero che aiuti a capire un po 'l'espressione regolare. : p

Ho provato a renderlo un po 'più semplice e più breve.

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

Se stai cercando 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]) $

Se qualcuno vuole sapere come funziona ecco la spiegazione. È davvero così semplice. Provalo: 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

Matematicamente è come:

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

Quindi, come puoi vedere normalmente, questo è il modello per gli indirizzi IP. Spero che aiuti a capire un po 'l'espressione regolare. : p

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

Ho adattato l'espressione regolare presa dalla libreria JGsoft RegexBuddy al linguaggio C (regcomp / regexec) e ho scoperto che funziona ma c'è un piccolo problema in alcuni sistemi operativi come Linux. Quell'espressione regolare accetta l'indirizzo ipv4 come 192.168.100.009 dove 009 in Linux è considerato un valore ottale, quindi l'indirizzo non è quello che pensavi. Ho cambiato quell'espressione regolare come segue:

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

l'utilizzo di tale espressione regolare ora 192.168.100.009 non è un indirizzo ipv4 valido mentre 192.168.100.9 è ok.

Ho modificato anche un'espressione regolare per l'indirizzo multicast ed è la seguente:

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

Penso che tu debba adattare l'espressione regolare alla lingua che stai usando per sviluppare la tua applicazione

Metto un esempio in java:

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

-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

(Questo è un DFA che corrisponde all'intero spazio dell'indirizzo (incluse le trasmissioni, ecc.) E nient'altro.

Penso che questo sia il più corto.

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

Ho trovato questo esempio molto utile, inoltre consente diverse notazioni ipv4.

codice di esempio utilizzando 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

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

Questa regex non accetterà 08.8.8.8 o 8.08.8.8 o 8.8.08.8 o 8.8.8.08

Trova un indirizzo IP valido fintanto che l'IP è racchiuso attorno a un carattere diverso dalle cifre (dietro o davanti all'IP). 4 riferimenti a ritroso creati: $ + {primo}. $ + {Secondo}. $ + {Terzo}. $ + {Avanti}

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.

Sostituendo parte di ogni ottetto con un valore effettivo, tuttavia puoi creare il tuo trova e sostituisci che è effettivamente utile per modificare gli IP nei file di testo:

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

È comunque possibile eseguire la sostituzione utilizzando i gruppi di riferimento a ritroso esattamente come prima.

Puoi avere un'idea di come quanto sopra corrispondeva di seguito:

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

Usando grep puoi vedere i risultati di seguito:

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

L'indirizzo IPv4 è una cosa molto complicata.

Nota : il rientro e il rivestimento sono solo a scopo illustrativo e non esistono nella RegEx reale.

\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

Questi indirizzi IPv4 sono convalidati dalla RegEx sopra.

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

Questi vengono rifiutati.

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

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

Sopra sarà regex per l'indirizzo IP come: 221.234.000.112 anche per 221.234.0.112, 221.24.03.112, 221.234.0.1

Puoi immaginare tutti i tipi di indirizzo come sopra

Userei PCRE e la defineparola chiave:

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

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

La ragione di ciò è evitare di ripetere lo (25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)schema quattro volte. Altre soluzioni come quella qui sotto funzionano bene, ma non cattura ogni gruppo come sarebbe richiesto da molti.

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

L'unico altro modo per avere 4 gruppi di acquisizione è ripetere lo schema quattro volte:

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

Catturare un ipv4 in perl è quindi molto semplice

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

La regexp IPv4 più precisa, semplice e compatta che posso immaginare è

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

Ma per quanto riguarda le prestazioni / efficienza di ... Scusa non lo so, chi se ne frega?

Prova questo:

\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

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

Di seguito è riportata l'espressione regex per convalidare l'indirizzo IP.

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

Modo semplice

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