web-dev-qa-db-fra.com

Validation des adresses IPv4 avec regexp

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

[chris@helios bashscripts]$ grep --version
grep (GNU grep) 2.7


[chris@helios bashscripts]$ 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
[chris@helios bashscripts]$ 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
[chris@helios bashscripts]$ grep -E '\b(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?(\.|$)){4}\b' <<< 192.168.255.255
[chris@helios bashscripts]$ 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 obtenu une réponse, mais d'autres réponses semblent montrer simplement comment déterminer 4 groupes de 1 à 3 nombres, ou ne fonctionnent pas pour moi.

Des idées? Merci!

regexvalidationip-addressipv4grep
43
Matthieu Cartier

Vous avez déjà une réponse satisfaisante, mais 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 le (\.|$) n'est requis que si le nombre est inférieur à 200.

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

Regex n'est pas l'outil pour ce travail. Il serait préférable d'écrire un analyseur qui sépare les quatre nombres et vérifie qu'ils sont compris dans l'intervalle [0,255]. La regex non fonctionnelle est déjà illisible!

24
Tim

Adresse IPv4 (capture précise) Correspondances 0.0.0.0 à 255.255.255.255 Utilisez cette expression régulière pour faire correspondre les numéros IP avec exactitude . Chacun des 4 numéros est stocké dans un groupe de capture afin de pouvoir 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

10
Valerij

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.x.y, 10.x.y.z, 172.16.x.y).

(?!(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 ligne de cours, formatés à des fins de lisibilité sur 3 lignes distinctes) Regular expression visualization

Démo Debuggex

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

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

Les IP qui vont (et devraient) fonctionner:

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 si quelqu'un d'autre cherche à valider les "adresses IP Internet n'incluant pas les adresses privées communes"

4
PhillipHolmes

Je pense que beaucoup de gens qui liront ce billet chercheront quelque chose de plus simple, même s’il autorise certaines adresses IP techniquement invalides.

C'est le plus simple que je pourrais trouver:

Python/Ruby/Perl:

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

grep -E (GNU Grep 3.1), awk (version 20070501) et sed:

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

La marionnette a permis ceci:

/(\d+[\.$]){4}/
2
Alex Harvey

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])$
2
Mickstar

'' '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 à 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 tous les 4 octets, alors ce n'est pas valide. Mais avant d'appliquer la condition, nous devons les convertir en entier car la valeur est dans une chaîne.

le groupe (0) imprime la sortie correspondante, alors que le groupe (1) imprime la première valeur correspondante, ici la valeur "25", etc. '' '

1
Shruti Lakkihal

Les réponses ci-dessus sont valables, mais que se passe-t-il si l'adresse IP n'est pas à la fin de la ligne et se situe entre text .. Cette expression rationnelle fonctionnera même avec cela.

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
1
Kushagra Gupta

J'ai réussi à construire une expression rationnelle à 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}
1
Vicky
(((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})))

Testez 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’adresse IP:

  • Tout numéro à un ou deux chiffres.

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

  • Tout numéro à trois chiffres commençant par 2 si le deuxième chiffre est 0 À 4.

  • Tout numéro à trois chiffres commençant par 25 si le troisième chiffre est 0 À 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 à un ou plusieurs chiffres de un à deux chiffres 0 à 99. (1\d{2}) correspond à tout numéro à trois chiffres commençant par 1 (1 suivi de deux chiffres) ou aux nombres 100 à 199. (2[0-4]\d) correspond aux nombres 200 à 249. (25[0-5]) correspond aux nombres 250 à 255. Chacune de ces sous-expressions est incluse dans une autre sous-expression avec un | entre chacune (de sorte que l'une des quatre sous-expressions doit correspondre, pas toutes). Après la plage de nombres, \. doit correspondre à ., puis la série entière (toutes les options numériques plus \.) est enfermée dans une autre sous-expression et répétée trois fois à l'aide de {3}. Enfin, la plage de chiffres est répétée (cette fois sans le \. final) pour correspondre au numéro d’adresse IP final. En limitant chacun des quatre nombres à des valeurs comprises entre 0 et 255, ce modèle peut en effet correspondre à des adresses IP valides et rejeter des adresses non valides.

Extrait de: Ben Forta. “Apprentissage des expressions régulières.”

Si aucun caractère n'est voulu au début de l'adresse IP ni à la fin, les métacaractères ^ et $ doivent être utilisés, 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})))$

Testez pour trouver les correspondances dans le texte, https://regex101.com/r/uAP31A/1

1
snr

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

(Il s’agit d’un DFA qui correspond à tout l’espace réservé aux adresses (y compris les émissions, etc.) et rien d’autre.

0
Jonathzen

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
0
AAP
    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 fonctionnait, 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 telle que 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";

l'utilisation de 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 une adresse de multidiffusion, qui 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.

Je mets 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();
        }
    }
0
Fabio Stafforte

J'ai trouvé cet exemple très utile, il permet en outre 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
0
internety

Trouve une adresse IP valide tant que l'adresse IP est encapsulée autour d'un caractère autre que des chiffres (derrière ou devant l'IP). 4 Références arrière créées: $ + {premier}. $ + {Deuxième}. $ + {Troisième}. $ + {Avant}

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.

Remplacer une partie de chaque octet par une valeur réelle, mais vous pouvez créer votre propre recherche et remplacement, ce qui est utile pour modifier des adresses IP dans des 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 la substitution à l'aide de groupes de références arrière exactement de la même manière qu'auparavant.

Vous pouvez avoir une idée de la façon dont ce qui précède correspond aux critères ci-dessous:

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
0
rda

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

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

0
fuweichin

J'utiliserais PCRE et le mot clé define: 

/^
 ((?&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 motif (25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?) quatre fois. D'autres solutions, comme celle ci-dessous, fonctionnent bien, mais ne prennent pas en compte chaque groupe, comme beaucoup le demanderaient.

/^((\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 facile 

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

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])$
0
Altan Gokcek

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

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

Cette expression régulière n'acceptera pas 08.8.8.8 ou 8.08.8.8 ou 8.8.08.8 ou 8.8.8.08

0
sudistack
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
0
Deepak_Mahalingam

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