Validation des adresses IPv4 avec regexp

J'ai essayé d'obtenir une regex efficace pour la validation IPv4, mais sans beaucoup de chance. Il semblait à un moment donné que je l'avais eu avec (25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?(\.|$)){4}, mais cela produit des résultats étranges:

$ 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

J'ai fait une recherche pour voir si cela avait déjà été demandé et répondu, mais d'autres réponses semblent simplement montrer comment déterminer 4 groupes de 1 à 3 numéros, ou ne fonctionnent pas pour moi.

Vous avez déjà une réponse de travail, mais juste au cas où vous seriez curieux de savoir ce qui n'allait pas avec votre approche d'origine, la réponse est que vous avez besoin de parenthèses autour de votre alternance, sinon cela (\.|$)n'est nécessaire que si le nombre est inférieur à 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]?)$

Accepter :

127.0.0.1
192.168.1.1
192.168.1.255
255.255.255.255
0.0.0.0
1.1.1.01

Rejeter :

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

Essayez en ligne avec des tests unitaires: https://www.debuggex.com/r/-EDZOqxTxhiTncN6/1

Version la plus récente, la plus courte et la moins lisible ( 55 caractères )

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

Cette version recherche le boîtier 250-5, après quoi il OUs intelligemment tous les cas possibles pour les 200-249 100-199 10-99cas. Notez que la |)pièce n'est pas une erreur, mais en fait le dernier cas pour la plage 0-9. J'ai également omis la ?:partie du groupe non capturant car nous ne nous soucions pas vraiment des éléments capturés, ils ne seraient pas capturés de toute façon si nous n'avions pas de correspondance complète en premier lieu.

Ancienne version plus courte (moins lisible) ( 63 caractères )

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

Ancienne version (lisible) ( 70 caractères )

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

Il utilise la recherche négative (?!)pour supprimer le cas où l'IP pourrait se terminer par un.

Réponse la plus ancienne ( 115 caractères )

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

Je pense que c'est l'expression régulière la plus précise et la plus stricte, elle n'accepte pas les choses comme 000.021.01.0.il semble que la plupart des autres réponses ici le font et nécessitent une expression régulière supplémentaire pour rejeter les cas similaires à celui-ci - c'est- 0à- dire les numéros de départ et une adresse IP qui se termine par un.

Adresse IPv4 (capture précise) Correspond à 0.0.0.0 à 255.255.255.255 Utilisez cette expression régulière pour faire correspondre les numéros IP avec précision. Chacun des 4 numéros est stocké dans un groupe de capture, vous pouvez donc y accéder pour un traitement ultérieur.

\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

extrait de la bibliothèque JGsoft RegexBuddy

Edit: cette (\.|$)partie semble bizarre

J'étais à la recherche de quelque chose de similaire pour les adresses IPv4 - une expression régulière qui empêchait également la validation des adresses IP privées couramment utilisées (192.168.xy, 10.xyz, 172.16.xy), donc utilisé des perspectives négatives pour accomplir cela:

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

(Ceux-ci doivent être sur une seule ligne bien sûr, formatés à des fins de lisibilité sur 3 lignes distinctes)

Démo Debuggex

Il n'est peut-être pas optimisé pour la vitesse, mais fonctionne bien lorsque vous recherchez uniquement de «vraies» adresses Internet.

Les choses qui vont (et devraient) échouer:

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 qui fonctionneront (et devraient):

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)

Fourni au cas où quelqu'un d'autre chercherait à valider les `` adresses IP Internet sans les adresses privées communes ''

Je pense que de nombreuses personnes qui liront cet article rechercheront des expressions régulières plus simples, même si elles correspondent à des adresses IP techniquement invalides. (Et, comme indiqué ailleurs, regex n'est probablement pas le bon outil pour valider correctement une adresse IP de toute façon.)

Supprimez ^et, le cas échéant, remplacez $par \b, si vous ne souhaitez pas faire correspondre le début / la fin de la ligne.

Expression régulière de base (BRE) (testée sur GNU grep, GNU sed et vim):

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

Expression régulière étendue (ERE):

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

ou:

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

Expression régulière compatible Perl (PCRE) (testé sur Perl 5.18):

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

ou:

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

Ruby (testé sur Ruby 2.1):

Bien que censé être PCRE, Ruby pour quelque raison que ce soit a autorisé cette expression régulière non autorisée par Perl 5.18:

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

Mes tests pour tous ceux-ci sont en ligne ici .

C'est un peu plus long que certains mais c'est ce que j'utilise pour faire correspondre les adresses IPv4. Simple sans compromis.

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

Les réponses ci-dessus sont valides mais que se passe-t-il si l'adresse IP n'est pas à la fin de la ligne et se trouve entre le texte ... Cette expression régulière fonctionnera même là-dessus.

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'

fichier texte d'entrée:

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

texte de sortie:

0.0.0.0
255.255.255.255
192.168.0.1
254.254.254.254
172.24.1.210
200.200.200.200

'' 'Ce code fonctionne pour moi, et est aussi simple que cela.

Ici, j'ai pris la valeur de ip et j'essaye de la faire correspondre avec 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 condition ci-dessus vérifie si la valeur dépasse 255 pour les 4 octets, alors ce n'est pas valide. Mais avant d'appliquer la condition, nous devons les convertir en entier puisque la valeur est dans une chaîne.

group (0) imprime la sortie correspondante, tandis que group (1) imprime la première valeur correspondante et ici c'est "25" et ainsi de suite. '' '

J'ai réussi à construire une regex à partir de toutes les autres réponses.

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

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

Pour le nombre de 0 à 255, j'utilise cette regex:

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

Au-dessus de regex correspondra un nombre entier de 0 à 255, mais pas 256.

Donc, pour IPv4, j'utilise cette 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})$

C'est dans cette structure: ^(N)((\.(N)){3})$où N est l'expression régulière utilisée pour faire correspondre le nombre de 0 à 255.
Cette expression régulière correspondra à IP comme ci-dessous:

0.0.0.0
192.168.1.2

mais pas ceux ci-dessous:

10.1.0.256
1.2.3.
127.0.1-2.3

Pour IPv4 CIDR (Classless Inter-Domain Routing), j'utilise cette expression régulière:

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

C'est dans cette structure: ^(N)((\.(N)){3})\/M$où N est l'expression régulière utilisée pour faire correspondre le nombre de 0 à 255, et M est l'expression régulière utilisée pour faire correspondre le nombre de 0 à 32.
Cette expression régulière correspondra au CIDR comme ci-dessous:

0.0.0.0/0
192.168.1.2/32

mais pas ceux ci-dessous:

10.1.0.256/16
1.2.3./24
127.0.0.1/33

Et pour la liste des adresses IPv4 CIDR comme "10.0.0.0/16", "192.168.1.1/32"j'utilise ce 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]))"))*)$

C'est dans cette structure: ^(“C”)((,([ ]*)(“C”))*)$où C est l'expression régulière utilisée pour correspondre au CIDR (comme 0.0.0.0/0).
Cette regex correspondra à la liste des CIDR comme ci-dessous:

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

mais pas ceux ci-dessous:

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

Peut-être que cela pourrait devenir plus court mais pour moi, c'est facile à comprendre si bien pour moi.

J'espère que cela aide!

Avec masque de sous-réseau:

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

Test pour trouver des correspondances dans le texte, https://regex101.com/r/9CcMEN/2

Voici les règles définissant les combinaisons valides dans chaque numéro d'une adresse IP:

• Tout numéro à un ou deux chiffres.

• Tout numéro à trois chiffres commençant par 1.

• Tout début de numéro à trois chiffres avec 2si le deuxième chiffre est 0 par 4.

• Tout début de numéro à trois chiffres avec 25si le troisième chiffre est 0 par 5.

Commençons par (((25[0-5])|(2[0-4]\d)|(1\d{2})|(\d{1,2}))\.), un ensemble de quatre sous-expressions imbriquées, et nous les examinerons dans l'ordre inverse. (\d{1,2})correspond à tout nombre à un ou deux chiffres ou à des nombres à 0travers 99. (1\d{2})correspond à tout nombre à trois chiffres commençant par 1( 1suivi de deux chiffres quelconques), ou à des nombres allant 100jusqu'à 199. (2[0-4]\d)fait correspondre les nombres à 200travers 249. (25[0-5])fait correspondre les nombres à 250travers 255. Chacune de ces sous-expressions est enfermée dans une autre sous-expression avec un |entre chacune (de sorte que l'une des quatre sous-expressions doit correspondre, pas toutes). Une fois que la plage de nombres \.correspond ., puis la série entière (toutes les options numériques plus\.) est inclus dans une autre sous-expression et répété trois fois en utilisant {3}. Enfin, la plage de nombres est répétée (cette fois sans la fin \.) pour correspondre au numéro d'adresse IP final. En limitant chacun des quatre nombres à des valeurs comprises entre 0et 255, ce modèle peut en effet correspondre à des adresses IP valides et rejeter des adresses invalides.

Extrait de: Ben Forta. "Apprendre les expressions régulières."

Si ni un caractère voulu au début de l' adresse IP , ni à la fin, ^et $métacaractères doit être utilisé, respectivement.

^(((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 pour trouver des correspondances dans le texte, https://regex101.com/r/uAP31A/1

J'ai essayé de le rendre un peu plus simple et plus court.

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

Si vous recherchez 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])$

Si quelqu'un veut savoir comment cela fonctionne, voici l'explication. C'est vraiment si simple. Essayez-le simplement: 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

Mathématiquement, c'est comme:

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

Donc, comme vous pouvez le voir normalement, c'est le modèle pour les adresses IP. J'espère que cela aide à comprendre un peu l'expression régulière. : p

J'ai essayé de le rendre un peu plus simple et plus court.

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

Si vous recherchez 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]) $

Si quelqu'un veut savoir comment cela fonctionne, voici l'explication. C'est vraiment si simple. Essayez-le simplement: 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

Mathématiquement, c'est comme:

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

Donc, comme vous pouvez le voir normalement, c'est le modèle pour les adresses IP. J'espère que cela aide à comprendre un peu l'expression régulière. : 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";

J'ai adapté l'expression régulière tirée de la bibliothèque JGsoft RegexBuddy au langage C (regcomp / regexec) et j'ai découvert que cela fonctionne mais il y a un petit problème dans certains systèmes d'exploitation comme Linux. Cette expression régulière accepte une adresse ipv4 comme 192.168.100.009 où 009 sous Linux est considéré comme une valeur octale, donc l'adresse n'est pas celle que vous pensiez. J'ai changé cette expression régulière comme suit:

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

utiliser cette expression régulière maintenant 192.168.100.009 n'est pas une adresse ipv4 valide alors que 192.168.100.9 est ok.

J'ai également modifié une expression régulière pour l'adresse multicast et c'est la suivante:

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

Je pense que vous devez adapter l'expression régulière au langage que vous utilisez pour développer votre application

J'ai mis un exemple en 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

(Ceci est un DFA qui correspond à tout l'espace d'adr (y compris les diffusions, etc.) et rien d'autre.

Je pense que celui-ci est le plus court.

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

J'ai trouvé cet exemple très utile, en plus il permet différentes notations ipv4.

exemple de code utilisant 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}

Cette regex n'acceptera pas 08.8.8.8 ou 8.08.8.8 ou 8.8.08.8 ou 8.8.8.08

Recherche une adresse IP valide tant que l'adresse IP est enroulée autour de tout caractère autre que des chiffres (derrière ou devant l'IP). 4 références inverses créées: $ + {first}. $ + {Second}. $ + {Third}. $ + {Ahead}

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.

En remplaçant une partie de chaque octect par une valeur réelle, vous pouvez cependant créer votre propre recherche et remplacement, ce qui est réellement utile pour modifier les adresses IP dans les fichiers texte:

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

Vous pouvez toujours effectuer un remplacement en utilisant des groupes de référence arrière exactement de la même manière qu'auparavant.

Vous pouvez avoir une idée de la correspondance ci-dessus:

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

En utilisant grep, vous pouvez voir les résultats ci-dessous:

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'adresse IPv4 est une chose très compliquée.

Remarque : l'indentation et la doublure sont uniquement à des fins d'illustration et n'existent pas dans le vrai 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

Ces adresses IPv4 sont validées par le RegEx ci-dessus.

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

Ceux-ci sont rejetés.

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

Ci-dessus sera regex pour l'adresse IP comme: 221.234.000.112 également pour 221.234.0.112, 221.24.03.112, 221.234.0.1

Vous pouvez imaginer toutes sortes d'adresses comme ci-dessus

J'utiliserais PCRE et le definemot - clé:

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

Démo: https://regex101.com/r/IB7j48/2

La raison en est d'éviter de répéter le (25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)motif quatre fois. D'autres solutions telles que celle ci-dessous fonctionnent bien, mais elles ne capturent pas chaque groupe comme cela serait demandé par beaucoup.

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

La seule autre façon d'avoir 4 groupes de capture est de répéter le motif quatre fois:

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

Capturer un ipv4 en perl est donc très simple

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

L'expression rationnelle IPv4 la plus précise, la plus simple et la plus compacte que je puisse imaginer est

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

Mais qu'en est-il de la performance / efficacité de ... Désolé, je ne sais pas, qui s'en soucie?

Essaye ça:

\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

Voici l'expression regex pour valider l'adresse 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]?)$

Moyen facile

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

Démo