Regex IP : Comment Valider les Adresses IPv4 et IPv6 en 2-3 Lignes de Code

Tu t’es déjà demandé comment vérifier si une adresse IP est valide dans ton code ? Ou peut-être que tu cherches à extraire toutes les adresses IP d’un fichier log ? Les expressions régulières (ou regex) sont là pour te sauver ! Je t’explique comment maîtriser les regex pour les adresses IP en quelques lignes de code seulement. C’est plus simple que tu ne le penses ! 🚀

📋 L’essentiel à retenir

• IPv4 : regex basique ^(\\d{1,3}\\.){3}\\d{1,3}$ pour la validation simple
• Validation complète : utiliser des regex plus élaborées pour vérifier que chaque octet est entre 0 et 255
• IPv6 : format plus complexe avec 8 groupes de 1-4 caractères hexadécimaux séparés par des :
• Performance : préférer les bibliothèques dédiées pour les validations intensives
• Test : toujours vérifier tes regex avec des outils comme Regex101 avant implémentation

🔍 Regex pour IPv4 : capturer les adresses en 4 octets

Tu connais sûrement les adresses IPv4, ces suites de 4 nombres séparés par des points comme 192.168.1.1. Pour les capturer avec une regex, on pourrait commencer par quelque chose de simple :

\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}

Cette expression cherche 4 groupes de 1 à 3 chiffres séparés par des points. Mais attention, cette regex n’est pas parfaite ! Elle accepterait des valeurs comme 999.999.999.999, alors qu’une IPv4 valide ne peut pas dépasser 255 pour chaque octet. 😱

Pour une validation plus stricte, essaie plutôt celle-ci :

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

Je sais, ça fait peur au premier coup d’œil ! Mais décomposons-la :

• Le motif 25[0-5] capture les nombres entre 250 et 255
• 2[0-4][0-9] capture les nombres entre 200 et 249
• [01]?[0-9][0-9]? capture les nombres entre 0 et 199
• Le tout est répété 4 fois avec des points entre chaque groupe

Si tu travailles avec JavaScript, voici comment l’utiliser :

💻 Exemple pratique en JavaScript

Imagine que tu veux vérifier si une chaîne est une adresse IPv4 valide :

const ipv4Regex = /^(?:(?: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]?)$/;
const isValidIPv4 = ipv4Regex.test(‘192.168.1.1’); // Renvoie true
const isInvalid = ipv4Regex.test(‘256.256.256.256’); // Renvoie false, comme attendu !

Tu peux aussi extraire toutes les adresses IPv4 d’un texte avec une regex légèrement modifiée :

const text = ‘Serveurs en ligne: 192.168.1.1 et 10.0.0.1 sont actifs’;
const allIPs = text.match(/\\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]?)\\b/g);
// Résultat: [‘192.168.1.1’, ‘10.0.0.1’]

⚡ Qu’en est-il des adresses IPv6 ?

Les adresses IPv6 sont beaucoup plus complexes : elles sont composées de 8 groupes de 1 à 4 caractères hexadécimaux séparés par des deux-points. Par exemple : 2001:0db8:85a3:0000:0000:8a2e:0370:7334. 🤯

Une regex basique pour IPv6 serait :

^(?:[0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$

Mais attention, cette regex ne prend pas en compte les formes abrégées d’IPv6 (avec des :: pour remplacer des groupes de zéros). Pour une validation complète, tu auras besoin d’une regex plus complexe :

^(?:[0-9a-fA-F]{1,4}:){6}(?:[0-9a-fA-F]{1,4}:[0-9a-fA-F]{1,4}|(?:(?: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-9a-fA-F]{1,4}:){5}(?:[0-9a-fA-F]{1,4}:[0-9a-fA-F]{1,4}|(?:(?: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-9a-fA-F]{1,4})?::(?:[0-9a-fA-F]{1,4}:){4}(?:[0-9a-fA-F]{1,4}:[0-9a-fA-F]{1,4}|(?:(?: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-9a-fA-F]{1,4}:){0,1}[0-9a-fA-F]{1,4})?::(?:[0-9a-fA-F]{1,4}:){3}(?:[0-9a-fA-F]{1,4}:[0-9a-fA-F]{1,4}|(?:(?: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-9a-fA-F]{1,4}:){0,2}[0-9a-fA-F]{1,4})?::(?:[0-9a-fA-F]{1,4}:){2}(?:[0-9a-fA-F]{1,4}:[0-9a-fA-F]{1,4}|(?:(?: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-9a-fA-F]{1,4}:){0,3}[0-9a-fA-F]{1,4})?::[0-9a-fA-F]{1,4}:(?:[0-9a-fA-F]{1,4}:[0-9a-fA-F]{1,4}|(?:(?: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-9a-fA-F]{1,4}:){0,4}[0-9a-fA-F]{1,4})?::(?:[0-9a-fA-F]{1,4}:[0-9a-fA-F]{1,4}|(?:(?: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-9a-fA-F]{1,4}:){0,5}[0-9a-fA-F]{1,4})?::[0-9a-fA-F]{1,4}$|^(?:(?:[0-9a-fA-F]{1,4}:){0,6}[0-9a-fA-F]{1,4})?::$

Wow ! C’est énorme, pas vrai ? 😅 Pour des cas complexes comme celui-ci, je te recommande d’utiliser des bibliothèques dédiées plutôt que d’écrire toi-même ces regex monstrueuses.

🛠 Astuces et bonnes pratiques

• Utilise des outils comme Regex101 pour tester et déboguer tes expressions régulières
• Pour des validations intensives, préfère les bibliothèques spécialisées dans la gestion d’IP
• Considère la performance : les regex très complexes peuvent ralentir ton application
• N’oublie pas de gérer les cas particuliers comme les adresses de loopback (127.0.0.1) ou IPv6 abrégées

Voici une table comparative qui pourrait t’aider à choisir la bonne approche :

Tu vois, valider des adresses IP avec des regex n’est pas si compliqué quand on comprend la logique ! 🎯 Pour les cas simples, une regex basique fera l’affaire. Et n’hésite pas à utiliser des outils en ligne comme Regex101 pour tester tes expressions. Allez, à toi de jouer maintenant !