Les patterns Regex courants que tout dev devrait mettre en favoris

Les expressions régulières sont des modèles réutilisables qui permettent de repérer des séquences de caractères précises dans un texte - imagine un outil de recherche surpuissant, disponible dans presque tous les langages de programmation. Que tu valides une adresse e-mail, que tu nettoies un numéro de téléphone soumis via un formulaire, ou que tu analyses un fichier de logs, une poignée de regex bien choisies couvrent 90 % de tes besoins. Ce guide rassemble les patterns les plus utiles, explique exactement ce que chacun fait, et te montre comment les adapter.

Rappel rapide de la syntaxe regex

Avant de plonger dans les patterns, voici un aide-mémoire des briques de base que tu rencontreras partout. Même si tu as déjà utilisé des expressions régulières, c'est pratique de tout avoir au même endroit.

Le guide des expressions régulières MDN Web Docs est la meilleure référence complète pour la syntaxe regex en JavaScript, et la plupart des patterns ci-dessous s'adaptent directement à Python, PHP, Java et Ruby avec de légères différences de flags.

Validation d'adresses e-mail

L'e-mail est le cas d'usage classique des expressions régulières - et aussi celui que la plupart des développeurs ratent en essayant d'être trop stricts. La spécification RFC 5322 autorise techniquement des adresses comme "very unusual"@example.com , que presque aucune regex ne gère correctement. Pour 99 % de la validation de saisie en conditions réelles, utilise un pattern pragmatique :

^[a-zA-Z0-9._%+\-]+@[a-zA-Z0-9.\-]+\.[a-zA-Z]{2,}$

Ce que fait chaque partie :

• [a-zA-Z0-9._%+\-]+ - partie locale (avant le @) ; autorise les points, signes plus, tirets, underscores
• @ - le signe arobase littéral
• [a-zA-Z0-9.\-]+ - nom de domaine, y compris les sous-domaines
• \.[a-zA-Z]{2,} - TLD d'au moins 2 caractères (.io, .com, .museum)

URL et adresses web

La correspondance de patterns d'URL couvre tout, de l'extraction de liens dans du texte brut à la validation d'un champ de site web saisi par l'utilisateur.

https?:\/\/(?:www\.)?[-a-zA-Z0-9@:%._+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b(?:[-a-zA-Z0-9()@:%_+.~#?&\/=]*)

• https? - correspond à la fois à http et à https
• (?:www\.)? - préfixe www optionnel
• [-a-zA-Z0-9@:%._+~#=]{1,256} - caractères du nom d'hôte, jusqu'à 256 caractères
• \.[a-zA-Z0-9()]{1,6} - TLD
• \b(?:[-a-zA-Z0-9()@:%_+.~#?&\/=]*) - chemin, chaîne de requête et fragment optionnels

Si tu as seulement besoin de valider (et non d'extraire), encadre le pattern avec les ancres ^ et $ .

Numéros de téléphone

Les numéros de téléphone sont notoirement difficiles à gérer, car leur format varie énormément selon les pays et les habitudes des utilisateurs. Deux patterns couvrent la plupart des cas :

Format États-Unis/Canada (NANP)

^(\+1[-.\s]?)?(\(?\d{3}\)?[-.\s]?)?\d{3}[-.\s]?\d{4}$

Correspond à : 555-867-5309 , (555) 867 5309 , +1.555.867.5309 , 5558675309

International (format E.164)

^\+[1-9]\d{6,14}$

E.164 est le format utilisé par la plupart des API de téléphonie (Twilio, AWS SNS). Il commence par + suivi d'un indicatif pays, sans espaces ni ponctuation.

Dates et heures

La correspondance de patterns de dates est courante dans les parseurs de logs, les validateurs de formulaires et les pipelines de données. Le format ciblé dépend de la source de tes données.

ISO 8601 (YYYY-MM-DD)

^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])$

Format américain (MM/DD/YYYY)

^(0[1-9]|1[0-2])\/(0[1-9]|[12]\d|3[01])\/\d{4}$

Heure sur 24 heures (HH:MM ou HH:MM:SS)

^([01]\d|2[0-3]):([0-5]\d)(?::([0-5]\d))?$

Note que ces patterns valident le format, pas la logique calendaire. Ils accepteront par exemple 2024-02-31 (le 31 février n'existe pas). Pour une validation stricte des dates, utilise la bibliothèque de dates de ton langage après la vérification par regex.

Validation de la robustesse des mots de passe

Les règles de mot de passe exigent généralement un mélange de types de caractères et une longueur minimale. Les lookaheads permettent de gérer ça proprement sans avoir besoin de plusieurs vérifications séparées.

Minimum 8 caractères, au moins une majuscule, une minuscule, un chiffre

^(?=.*[a-z])(?=.*[A-Z])(?=.*\d).{8,}$

Robuste : 8+ caractères, majuscule, minuscule, chiffre et caractère spécial

^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[!@#$%^&*()_+\-=\[\]{};':"\\|,.<>\/?]).{8,}$

Chaque (?=.*[...]) est un lookahead qui parcourt toute la chaîne à la recherche d'au moins un caractère correspondant. Le .{8,} final impose la longueur minimale. Tu peux remplacer {8,} par {12,} pour imposer un minimum de 12 caractères, conformément aux recommandations NIST SP 800-63B .

Adresses IP

IPv4

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

Ce pattern rejette correctement des valeurs comme 999.0.0.1 en faisant correspondre chaque octet explicitement entre 0 et 255.

IPv6 (simplifié)

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

Ce pattern gère le format complet à 8 groupes. Pour la notation compressée (par exemple ::1 pour le loopback), le pattern devient nettement plus complexe - à ce stade, utiliser une bibliothèque réseau est plus fiable que la regex.

HTML et balisage

Quelques patterns ciblés sont vraiment utiles ici. Le conseil général "ne parse pas du HTML avec une regex" reste valable pour les documents complets - utilise un vrai parseur DOM comme BeautifulSoup ou DOMParser pour ça. Mais pour des tâches spécifiques et bien délimitées, la regex fait très bien l'affaire.

Supprimer toutes les balises HTML

<[^>]*>

Extraire le contenu d'une balise spécifique (par exemple <title>)

Le groupe capturant 1 contient le texte du titre.

Correspondre aux codes couleur hexadécimaux HTML

#([a-fA-F0-9]{6}|[a-fA-F0-9]{3})\b

Correspond à la fois à la notation abrégée sur 3 chiffres ( #fff ) et à la forme complète sur 6 chiffres ( #ffffff ).

Patterns utilitaires du quotidien

Ces patterns reviennent constamment dans tous types de projets.

Slug (chaîne compatible avec les URL)

^[a-z0-9]+(?:-[a-z0-9]+)*$

Correspond à des chaînes comme my-blog-post-2024 . Pas de majuscules, pas de tirets en début ou fin, pas de tirets doubles.

Numéro de carte bancaire (format de base, sans espaces)

^(?:4[0-9]{12}(?:[0-9]{3})?|5[1-5][0-9]{14}|3[47][0-9]{13}|6(?:011|5[0-9]{2})[0-9]{12})$

• Commence par 4 - Visa (13 ou 16 chiffres)
• Commence par 51-55 - Mastercard (16 chiffres)
• Commence par 34 ou 37 - Amex (15 chiffres)
• Commence par 6011 ou 65 - Discover (16 chiffres)

Normalisation des espaces (réduction des espaces multiples)

\s{2,}

Remplace les correspondances par un espace unique pour nettoyer les saisies utilisateur désordonnées ou le texte extrait par scraping.

Chiffres uniquement

^\d+$

Caractères alphanumériques uniquement

^[a-zA-Z0-9]+$

Trouver une ligne contenant un mot (insensible à la casse avec flag)

^.*\bword\b.*$

La limite de mot \b empêche de trouver word à l'intérieur de password .

Extraire des numéros de version (semver)

\bv?(\d+)\.(\d+)\.(\d+)(?:-([a-zA-Z0-9.]+))?(?:\+([a-zA-Z0-9.]+))?\b

Capture le numéro majeur, mineur, patch, le label de pré-release et les métadonnées de build à partir de chaînes comme v2.14.0-beta.1+build.42 .

Flags et conseils pratiques

Les expressions régulières se comportent différemment selon les flags appliqués. Voici les plus couramment utilisés :

Quelques bonnes habitudes qui t'éviteront bien des heures de débogage :

• Teste toujours avec des cas limites - chaîne vide, longueur maximale, caractères Unicode, et chaînes presque valides mais pas tout à fait.
• Utilise les groupes non-capturants (?:...) quand tu n'as pas besoin du contenu capturé - c'est plus rapide et plus lisible que les groupes capturants.
• Ancre tes patterns de validation avec ^ et $ pour éviter qu'une sous-chaîne valide au sein d'une chaîne invalide ne passe à travers les mailles.
• Méfie-toi du backtracking catastrophique - des quantificateurs imbriqués comme (a+)+ peuvent bloquer le moteur regex sur une entrée malformée. Garde tes quantificateurs simples et précis.
• Utilise un testeur de regex pendant la construction de tes patterns. regex101.com affiche en temps réel le détail des correspondances, explique chaque token, et te permet de basculer entre PCRE, JavaScript, Python et d'autres variantes.

Teste et valide tes expressions régulières sans te prendre la tête

Construire des patterns regex fiables pour la validation de saisie est bien plus rapide avec les bons outils. Explore nos utilitaires gratuits pour développeurs pour nettoyer, vérifier et transformer du texte avec des expressions régulières et bien plus encore.

Essaie nos outils gratuits →