Regex PHP : Guide complet + les 10 Regex les plus utilisées

Si vous avez déjà eu besoin de rechercher un mot précis dans un texte, de vérifier la validité d’une adresse e-mail ou encore de remplacer une partie d’une chaîne de caractères, alors vous avez déjà rencontré une problématique que les regex PHP (expressions régulières) résolvent brillamment.

Les expressions régulières, aussi appelées expressions rationnelles, sont un langage puissant qui permet de décrire des modèles de texte. Que vous soyez débutant en développement ou programmeur confirmé, comprendre et savoir utiliser les regex est une compétence précieuse. Elles sont intégrées dans de nombreux langages, dont PHP, pilier du développement web.

Dans ce guide, vous allez découvrir pas à pas ce que sont les regex, pourquoi elles sont utiles, comment les employer efficacement et dans quels cas elles deviennent incontournables. Nous prendrons le temps de décortiquer la syntaxe, souvent perçue comme complexe, et nous illustrerons chaque point avec des exemples concrets en PHP.

À la fin de ce tutoriel, vous aurez non seulement une compréhension claire des regex, mais vous saurez également les utiliser dans vos projets web pour valider des formulaires, filtrer du texte ou manipuler des données de manière élégante et rapide.

• Qu’est-ce qu’une regex ?
• À quoi servent les regex ?
• Les avantages des regex
• La syntaxe des regex
• Utilisation des regex en PHP
• Les composants essentiels d’une regex
  • Les métacaractères de base
  • Les quantificateurs
  • Les ancres
  • Les classes prédéfinies
  • Les drapeaux (modificateurs)
• Différences entre regex en PHP et en JavaScript
• Les groupes capturants
  • Groupes non capturants
• Les lookaheads et lookbehinds
  • Lookahead positif : (?=…)
  • Lookahead négatif : (?!…)
  • Lookbehind positif : (?<=…)
  • Lookbehind négatif : (?
• Remplacements dynamiques
• Utilisation combinée avec split
• Bonnes pratiques pour écrire des regex
• Quand utiliser une regex ?
  • Quand éviter une regex ?
  • Optimiser ses regex
  • Stratégie pour écrire une regex
  • Bonnes pratiques en projet web
• BONUS : Les 10 regex les plus utilisées en PHP et JS
  • 1. Vérifier une adresse email
  • 2. Vérifier un numéro de téléphone français
  • 3. Vérifier un code postal français
  • 4. Vérifier une URL
  • 5. Vérifier un mot de passe fort
  • 6. Vérifier une date au format JJ/MM/AAAA
  • 7. Vérifier une adresse IP
  • 8. Extraire toutes les balises HTML
  • 9. Vérifier une chaîne contenant uniquement des lettres
  • 10. Vérifier un nombre entier positif

Qu’est-ce qu’une regex ?

Une regex, contraction de « regular expression« , est une suite de caractères qui définit un motif de recherche. Plutôt que de chercher un mot ou une phrase de manière brute, vous allez créer une règle qui décrit un ensemble de correspondances possibles.

Par exemple, au lieu de dire « je veux trouver le mot chat », vous pourriez écrire une regex qui dit « je veux trouver n’importe quel mot qui commence par ch et qui se termine par t ». Cela permet d’englober plusieurs cas possibles en une seule règle.

Les regex ne se limitent pas aux mots. Elles peuvent aussi servir à repérer des chiffres, des symboles, des espaces, des répétitions ou des motifs complexes. Et à effectuer des vérifications !

À quoi servent les regex ?

Les utilisations des regex sont multiples et dépassent largement la simple recherche de mots. Voici quelques exemples concrets :

• Vérifier si une adresse e-mail est correctement formatée
• Contrôler si un mot de passe respecte certaines règles (longueur minimale, majuscules, chiffres, symboles)
• Extraire un numéro de téléphone ou une date dans un texte
• Remplacer des mots interdits par des astérisques
• Découper une chaîne de caractères selon un motif particulier
• Identifier les balises HTML dans une page

Dans le développement web, les regex sont présentes à la fois côté serveur (PHP) et côté client (JavaScript). Cela permet de sécuriser et de contrôler les données des utilisateurs dès leur saisie, puis de les valider à nouveau avant leur enregistrement.

Les avantages des regex

Les regex offrent plusieurs avantages majeurs qui expliquent leur popularité dans le monde du développement.

D’abord, elles permettent de faire en quelques lignes ce qui prendrait des dizaines de lignes de code avec des conditions classiques. Au lieu de vérifier caractère par caractère si une chaîne correspond à une règle, la regex effectue cette vérification instantanément.

Ensuite, elles sont universelles. Une regex écrite dans un langage peut souvent être adaptée facilement dans un autre. Cette portabilité en fait un outil que vous n’aurez pas à réapprendre à chaque changement de langage.

Enfin, elles sont très flexibles. Grâce à elles, vous pouvez gérer des cas extrêmement simples (comme vérifier si une chaîne contient un mot donné) mais aussi des cas très complexes (comme identifier une adresse IP ou une URL valide).

La syntaxe des regex

Pour bien comprendre les regex, il faut d’abord se familiariser avec leur syntaxe. Une regex est construite à partir de symboles et de règles qui décrivent le motif de recherche.

Prenons quelques bases :

• Le point (.) signifie « n’importe quel caractère ».
• Les crochets ([]) permettent de définir un ensemble de caractères. Par exemple [abc] correspond à « a » ou « b » ou « c ».
• Le tiret (-) dans des crochets définit une plage. [0-9] signifie « tout chiffre entre 0 et 9 ».
• L’étoile (*) indique « zéro ou plusieurs occurrences ».
• Le plus (+) indique « une ou plusieurs occurrences ».
• Le point d’interrogation (?) indique « zéro ou une occurrence ».
• Les accolades ({n,m}) permettent de définir une répétition précise. Par exemple a{2,4} correspond à deux à quatre « a ».
• Le caractère accent circonflexe (^) signifie « début de ligne ».
• Le symbole dollar ($) signifie « fin de ligne ».

Voici un exemple simple :

/^[0-9]+$/

Cette regex vérifie si une chaîne est composée uniquement de chiffres.

Utilisation des regex en PHP

En PHP, l’utilisation des regex se fait principalement avec la fonction preg_match pour vérifier une correspondance, preg_replace pour effectuer un remplacement, et preg_split pour découper une chaîne.

Exemple :

<?php
$texte = "Bonjour 123";
if (preg_match("/[0-9]+/", $texte)) {
    echo "Il y a au moins un chiffre dans le texte.";
}
?>

Ici, preg_match renvoie vrai (true) car le texte contient des chiffres.

Les composants essentiels d’une regex

Pour maîtriser les regex, il est important de comprendre les éléments qui les composent. Chaque symbole a un rôle particulier et peut être combiné avec d’autres pour former des règles puissantes. Comme nous l’avons vu plus haut pour certains éléments :

Les métacaractères de base

• Le point (.) : il représente n’importe quel caractère, sauf par défaut le retour à la ligne. Ainsi, la regex a.ccorrespond à « abc », « axc » ou « a-c ».
• Les crochets ([]) : ils servent à définir un ensemble de caractères autorisés. Par exemple, [abc] signifie « a ou b ou c ». De même, [0-9] représente tous les chiffres de 0 à 9.
• Le tiret (-) : utilisé dans les crochets, il définit une plage de caractères. [a-z] correspond à toutes les lettres minuscules.
• Le circonflexe (^) dans les crochets : il inverse l’ensemble. Par exemple, [^0-9] correspond à tout caractère qui n’est pas un chiffre.
• L’accolade ({}) : elle permet de définir le nombre de répétitions d’un caractère ou d’un motif. a{2,4} signifie « deux à quatre a consécutifs ».

Les quantificateurs

Les quantificateurs définissent combien de fois un caractère ou un motif peut apparaître.

• * : zéro ou plusieurs occurrences.
• + : une ou plusieurs occurrences.
• ? : zéro ou une occurrence.
• {n} : exactement n occurrences.
• {n,} : au moins n occurrences.
• {n,m} : entre n et m occurrences.

Exemple :

/\d{2,4}/

Cette regex correspond à un nombre composé de deux à quatre chiffres.

Les ancres

Les ancres ne correspondent pas à un caractère précis, mais à une position dans le texte.

• ^ : début de ligne ou de chaîne.
• $ : fin de ligne ou de chaîne.

Exemple :

/^Bonjour$/

Cette regex ne correspond qu’à la chaîne « Bonjour » exactement, sans rien avant ni après.

Les classes prédéfinies

Pour simplifier l’écriture, certaines classes sont déjà définies :

• \d : correspond à un chiffre, équivalent à [0-9].
• \D : tout sauf un chiffre.
• \w : une lettre, un chiffre ou un underscore, équivalent à [A-Za-z0-9_].
• \W : tout sauf ce qui est défini par \w.
• \s : un espace, une tabulation ou un saut de ligne.
• \S : tout sauf un espace blanc.

Les drapeaux (modificateurs)

Les regex disposent de drapeaux, aussi appelés modificateurs, qui changent leur comportement.

En PHP, ils s’ajoutent après le dernier délimiteur. Exemple : /motif/i.

Voici les plus utilisés :

• i : rend la recherche insensible à la casse (majuscule/minuscule).
• g : recherche globale, c’est-à-dire toutes les correspondances et pas seulement la première.
• m : mode multiligne, où ^ et $ correspondent respectivement au début et à la fin de chaque ligne.
• u : permet de gérer correctement les caractères Unicode

Ici, grâce aux modificateurs g et i, la recherche trouve toutes les occurrences, peu importe la casse.

Différences entre regex en PHP et en JavaScript

Même si les regex se ressemblent beaucoup dans ces deux langages, il existe quelques différences notables.

• En PHP, les regex s’utilisent principalement avec les fonctions preg_ (comme preg_match, preg_replace, preg_split). Elles nécessitent souvent des délimiteurs comme /, # ou ~.
• En JavaScript, les regex sont intégrées dans le langage sous forme littérale (/motif/) ou via l’objet RegExp. Les méthodes principales sont test, match, replace, split et exec.
• Unicode : JavaScript a longtemps eu des difficultés avec les caractères Unicode complexes (comme les emojis ou certaines lettres accentuées), mais depuis ES6, le drapeau u permet de mieux les gérer. PHP, quant à lui, s’appuie sur PCRE (Perl Compatible Regular Expressions), qui gère l’Unicode si vous ajoutez le modificateur u.
• Performances : PHP et JavaScript sont tous deux rapides pour des cas simples, mais PHP peut être plus performant pour des regex complexes appliquées à de gros volumes de données côté serveur.

Les groupes capturants

Les groupes capturants permettent d’encadrer une partie d’une regex entre parenthèses. Cela sert à deux choses principales :

1. Appliquer un quantificateur à un groupe entier plutôt qu’à un seul caractère.
2. Capturer une sous-chaîne pour la réutiliser ensuite.

Exemple simple :

/(ab)+/

Cette regex correspond à une ou plusieurs répétitions du groupe « ab ».

En PHP :

<?php
$texte = "abababc";
if (preg_match("/(ab)+/", $texte, $matches)) {
    echo "Trouvé : " . $matches[0]; // Affiche "ababab"
}
?>

Groupes non capturants

Si vous ne souhaitez pas capturer mais simplement regrouper, vous pouvez utiliser (?: ...).

Exemple :

/(?:ab)+c/

Cela signifie : « une ou plusieurs répétitions de ab suivies d’un c », mais sans stocker le contenu de ab dans un groupe.

Les lookaheads et lookbehinds

Les lookarounds permettent de faire des vérifications avant ou après un motif, sans inclure ces caractères dans la correspondance finale.

Lookahead positif : (?=...)

Cela signifie : « il doit être suivi de… ».

Exemple :

/\w+(?=:)/

Cela correspond à un mot suivi de :, mais sans inclure le : dans le résultat.

Lookahead négatif : (?!...)

Cela signifie : « il ne doit pas être suivi de… ».

Exemple :

/\d{2}(?!€)/

Cela correspond à deux chiffres qui ne sont pas suivis du symbole €.

Lookbehind positif : (?<=...)

Cela signifie : « il doit être précédé de… ».

Exemple :

/(?<=€)\d+/

Cela capture les chiffres précédés du symbole €.

Utiliser lookbehind positif en PHP :

<?php
$texte = "Le prix est de €45.";
if (preg_match("/(?<=€)\d+/", $texte, $matches)) {
    echo "Montant : " . $matches[0]; // Affiche 45
}
?>

Lookbehind négatif : (?<!...)

Cela signifie : « il ne doit pas être précédé de… ».

Exemple :

/(?<!€)\d+/

Cela capture des chiffres qui ne sont pas précédés du symbole €.

⚠️ Attention : tous les moteurs ne supportent pas les lookbehinds. Par exemple, en JavaScript, leur support est relativement récent (ES2018).

Remplacements dynamiques

Les regex ne servent pas qu’à chercher : elles permettent aussi de remplacer des portions de texte.

En PHP, on utilise preg_replace.

Exemple :

<?php
$texte = "Mon numéro est 0612345678.";
$texte_modifie = preg_replace("/(\d{2})(?=\d)/", "$1-", $texte);
echo $texte_modifie; // Mon numéro est 06-12-34-56-78.
?>

Ici, on insère un tiret après chaque groupe de deux chiffres.

Utilisation combinée avec split

Les regex sont utiles pour découper un texte selon un motif.

Exemple : séparer un texte par tout type de séparateur (espace, virgule, point, point-virgule).

Des formations informatique pour tous !

Débutant ou curieux ? Apprenez le développement web, le référencement, le webmarketing, la bureautique, à maîtriser vos appareils Apple et bien plus encore…

Formateur indépendant, professionnel du web depuis 2006, je vous accompagne pas à pas et en cours particulier, que vous soyez débutant ou que vous souhaitiez progresser. En visio, à votre rythme, et toujours avec pédagogie.

Découvrez mes formations Qui suis-je ?

En PHP :

<?php
$texte = "Bonjour, comment ça va ? Bien; merci.";
$mots = preg_split("/[ ,;?.!]+/", $texte);
print_r($mots);
?>

Le texte est transformé en tableau de mots.

Bonnes pratiques pour écrire des regex

Commencez simple : Lorsque vous concevez une regex, ne cherchez pas à tout faire en une seule ligne. Construisez-la étape par étape, en testant chaque ajout.

Utilisez des commentaires : En PHP, vous pouvez activer le mode verbeux avec le modificateur x, qui permet d’ajouter des espaces et des commentaires.

Exemple :

<?php
$regex = "/
    ^              # Début de la chaîne
    [A-Za-z0-9._%+-]+   # Nom d’utilisateur
    @              # Symbole @
    [A-Za-z0-9.-]+      # Nom de domaine
    \.[A-Za-z]{2,}      # Extension
    $              # Fin de la chaîne
/x";
$email = "[email protected]";
echo preg_match($regex, $email) ? "Valide" : "Invalide";
?>

Cela rend vos regex beaucoup plus lisibles.

Testez vos regex avec des outils : De nombreux outils en ligne (comme regex101.com) permettent de tester vos regex en temps réel et d’obtenir des explications sur chaque partie.

Préférez la clarté à l’extrême concision : Il vaut mieux une regex un peu plus longue mais lisible qu’une regex ultracondensée que personne ne comprend.

Quand utiliser une regex ?

Les regex sont extrêmement puissantes, mais elles ne doivent pas devenir un réflexe systématique. Elles sont particulièrement utiles dans certains cas précis :

• Validation de formats simples : adresses e-mail, numéros de téléphone, codes postaux, mots de passe.
• Recherche et extraction ciblée : extraire un prix dans un texte, identifier des balises, trouver un mot-clé dans une chaîne.
• Nettoyage de texte : supprimer les caractères non désirés, censurer des mots, reformater une chaîne.
• Découpage intelligent : séparer un texte selon plusieurs séparateurs à la fois.

Dans ces cas, la regex vous permet d’écrire moins de code et de garder un contrôle fin sur vos règles.

Quand éviter une regex ?

Il existe cependant des cas où les regex ne sont pas le meilleur choix.

• Analyse complexe de structures hiérarchiques : par exemple, un fichier XML ou HTML entier. Il vaut mieux utiliser un parseur dédié.
• Cas simples : si vous devez juste vérifier si une chaîne contient un mot précis, une fonction classique comme strpos()en PHP ou includes() en JavaScript est plus lisible et plus rapide.
• Performance critique : dans un script qui manipule des millions de lignes de texte, une regex trop complexe peut devenir un goulet d’étranglement.

La règle d’or est simple : utilisez une regex quand elle apporte un vrai gain en lisibilité et en concision, pas juste parce que vous le pouvez.

Optimiser ses regex

Éviter les pièges de performance : Certaines regex peuvent provoquer ce qu’on appelle une catastrophe exponentielle, où le moteur met beaucoup de temps à tester toutes les combinaisons possibles.

Exemple problématique :

/(a+)+b/

Sur une chaîne comme "aaaaaaaaaaaaaaaaaaaa", cette regex peut devenir extrêmement lente.

Solution : essayez de simplifier vos motifs et d’éviter les quantificateurs imbriqués sur des motifs trop génériques.

Préférer les classes prédéfinies : Au lieu d’écrire [0-9], utilisez \d. Au lieu de [A-Za-z0-9_], préférez \w. Cela rend vos regex plus compactes et plus rapides à lire.

Stratégie pour écrire une regex

1. Définir le besoin avec des mots simples : par exemple, « je veux repérer un nombre à deux chiffres suivi de la lettre € ».
2. Traduire progressivement : d’abord \d{2} pour le nombre, puis ajouter €.
3. Tester chaque étape : n’écrivez pas une regex complète sans la tester en chemin.
4. Utiliser des groupes : pour clarifier et isoler les parties importantes.
5. Documenter : si la regex est complexe, ajoutez un commentaire dans le code.

Bonnes pratiques en projet web

• Côté client et côté serveur : si vous validez un formulaire avec une regex en JavaScript, n’oubliez pas de refaire la validation côté serveur en PHP. Le JavaScript peut être désactivé ou contourné.
• Centraliser les regex : si un même motif est utilisé dans plusieurs parties du projet (exemple : vérification d’e-mail), créez une fonction dédiée pour éviter les doublons.
• Utiliser des constantes : dans les gros projets PHP, stockez vos regex dans des constantes avec des noms explicites. Cela rend le code plus lisible.

BONUS : Les 10 regex les plus utilisées en PHP et JS

Les expressions régulières peuvent sembler complexes au premier abord, mais certaines d’entre elles reviennent très souvent dans la pratique du développement. Explorerons dix regex incontournables. Chaque exemple sera accompagné d’une explication claire, ainsi que d’une démonstration en PHP et en JavaScript.

1. Vérifier une adresse email

Une des utilisations les plus courantes de la regex est de contrôler la validité d’un email.

Regex :

^[\w.-]+@[\w.-]+\.[a-zA-Z]{2,6}$

Explication :

• ^[\w.-]+ : commence par un mot (lettres, chiffres, underscore), un point ou un tiret
• @ : doit contenir un arobase
• [\w.-]+ : suivi d’un nom de domaine
• \.[a-zA-Z]{2,6}$ : termine par une extension de 2 à 6 lettres

PHP :

$email = "[email protected]";
if (preg_match("/^[\w.-]+@[\w.-]+\.[a-zA-Z]{2,6}$/", $email)) {
    echo "Email valide";
} else {
    echo "Email invalide";
}

JavaScript :

let email = "[email protected]";
let regex = /^[\w.-]+@[\w.-]+\.[a-zA-Z]{2,6}$/;
console.log(regex.test(email) ? "Email valide" : "Email invalide");

2. Vérifier un numéro de téléphone français

Regex :

^(?:\+33|0)[1-9](?:\d{2}){4}$

Explication :

• Accepte les formats +33 ou 0
• Suivi d’un chiffre de 1 à 9
• Puis 4 groupes de 2 chiffres

PHP :

$tel = "0612345678";
if (preg_match("/^(?:\+33|0)[1-9](?:\d{2}){4}$/", $tel)) {
    echo "Numéro valide";
}

JavaScript :

let tel = "0612345678";
let regex = /^(?:\+33|0)[1-9](?:\d{2}){4}$/;
console.log(regex.test(tel) ? "Numéro valide" : "Numéro invalide");

3. Vérifier un code postal français

Regex :

^\d{5}$

Explication :

• ^\d{5}$ signifie que le code postal doit contenir exactement 5 chiffres.

PHP :

$cp = "75001";
if (preg_match("/^\d{5}$/", $cp)) {
    echo "Code postal valide";
}

JavaScript :

let cp = "75001";
let regex = /^\d{5}$/;
console.log(regex.test(cp) ? "Code postal valide" : "Code postal invalide");

4. Vérifier une URL

Regex :

^(https?:\/\/)?([\w.-]+)\.([a-z]{2,6})([\/\w .-]*)*\/?$

Explication :

• https? : accepte http ou https
• ([\w.-]+)\.([a-z]{2,6}) : domaine et extension
• ([\/\w .-]*)* : chemin optionnel

PHP :

$url = "https://www.exemple.com/test";
if (preg_match("/^(https?:\/\/)?([\w.-]+)\.([a-z]{2,6})([\/\w .-]*)*\/?$/", $url)) {
    echo "URL valide";
}

JavaScript :

let url = "https://www.exemple.com/test";
let regex = /^(https?:\/\/)?([\w.-]+)\.([a-z]{2,6})([\/\w .-]*)*\/?$/;
console.log(regex.test(url) ? "URL valide" : "URL invalide");

5. Vérifier un mot de passe fort

Regex :

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

Explication :

• Au moins une minuscule, une majuscule, un chiffre et un caractère spécial
• Minimum 8 caractères

PHP :

$pwd = "Test@1234";
if (preg_match("/^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$/", $pwd)) {
    echo "Mot de passe fort";
}

JavaScript :

let pwd = "Test@1234";
let regex = /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$/;
console.log(regex.test(pwd) ? "Mot de passe fort" : "Mot de passe faible");

6. Vérifier une date au format JJ/MM/AAAA

Regex :

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

Explication :

• Jour entre 01 et 31
• Mois entre 01 et 12
• Année sur 4 chiffres

PHP :

$date = "25/12/2024";
if (preg_match("/^(0[1-9]|[12][0-9]|3[01])\/(0[1-9]|1[0-2])\/\d{4}$/", $date)) {
    echo "Date valide";
}

JavaScript :

let date = "25/12/2024";
let regex = /^(0[1-9]|[12][0-9]|3[01])\/(0[1-9]|1[0-2])\/\d{4}$/;
console.log(regex.test(date) ? "Date valide" : "Date invalide");

7. Vérifier une adresse IP

Regex :

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

PHP :

$ip = "192.168.1.1";
if (preg_match("/^((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]?)$/", $ip)) {
    echo "Adresse IP valide";
}

JavaScript :

let ip = "192.168.1.1";
let regex = /^((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]?)$/;
console.log(regex.test(ip) ? "Adresse IP valide" : "Adresse IP invalide");

8. Extraire toutes les balises HTML

Regex :

<("[^"]*"|'[^']*'|[^'">])*> 

PHP :

$html = "<p>Hello</p><a href='#'>Lien</a>";
preg_match_all("/<(\"[^\"]*\"|'[^']*'|[^'\">])*>/", $html, $matches);
print_r($matches[0]);

JavaScript :

let html = "<p>Hello</p><a href='#'>Lien</a>";
let regex = /<("[^"]*"|'[^']*'|[^'">])*>/g;
console.log(html.match(regex));

9. Vérifier une chaîne contenant uniquement des lettres

Regex :

^[A-Za-zÀ-ÿ]+$

PHP :

$nom = "Dupont";
if (preg_match("/^[A-Za-zÀ-ÿ]+$/", $nom)) {
    echo "Nom valide";
}

JavaScript :

let nom = "Dupont";
let regex = /^[A-Za-zÀ-ÿ]+$/;
console.log(regex.test(nom) ? "Nom valide" : "Nom invalide");

10. Vérifier un nombre entier positif

Regex :

^[0-9]+$

PHP :

$nombre = "12345";
if (preg_match("/^[0-9]+$/", $nombre)) {
    echo "Nombre valide";
}

JavaScript :

let nombre = "12345";
let regex = /^[0-9]+$/;
console.log(regex.test(nombre) ? "Nombre valide" : "Nombre invalide");

Ces dix regex représentent la majorité des besoins quotidiens des développeurs, que ce soit pour valider un formulaire, sécuriser une saisie ou encore extraire des données d’une chaîne de texte. En maîtrisant ces expressions régulières, vous aurez déjà une excellente base pour aborder des cas plus complexes et personnaliser vos propres modèles selon vos besoins.

Les regex sont un outil incontournable pour tout développeur web travaillant en PHP et en JavaScript. Elles permettent de valider des données, de rechercher et de manipuler des textes de manière élégante et efficace.

Nous avons vu dans ce tutoriel :

• Ce que sont les regex et à quoi elles servent.
• Leurs avantages et leurs limites.
• La syntaxe de base et avancée (métacaractères, quantificateurs, ancres, groupes, lookaheads/lookbehinds).
• Des exemples concrets : validation d’e-mail, mots de passe, numéros de téléphone, URL, filtrage de mots.
• Les bonnes pratiques pour écrire des regex claires, performantes et maintenables.

En résumé, maîtriser les regex, c’est ajouter une corde précieuse à votre arc de développeur. Même si elles peuvent sembler complexes au départ, avec de la pratique et une approche méthodique, elles deviennent un outil indispensable.

Alban

Fondateur de l’agence Créa-troyes.
Intervenant en Freelance.
Contactez-moi

crea-troyes.fr