Les expressions régulières (RegEx)



Dans ma série comment gérer les chaînes de caractères, nous avons vu :

Comment ne pas parler des expressions régulières ou regEx ?

En effet les RegEx sont un outil indispensable pour manipuler, rechercher, remplacer des chaînes de caractères. Impossible donc de ne pas en parler dés lors que l’on traite des données de ce type.

Avant de commencer …

Avant de commencer, j’aimerai préciser que l’objectif de cet article n’est pas de faire un cours ou une référence sur les RegEx. Loin de moi, en effet, l’idée de faire un cours magistral sur les RegEx. Ça ne servirait pas à grand chose … car les RegEx, ça se pratique. Et puis de toute façon il y a vraiment plein de super site là dessus sur le net 😉

Nous parcourrons quelques liens utiles pour apprendre les RegEx. Ensuite nous verrons comment les pratiquer efficacement (au travers de cheat sheets, outils, etc.). Puis nous verrons des exemples de mise en œuvre avec des langages tels que Python ou Java.

L’idée est donc de fournir une fiche pratique et utile des RegEx !

Mémento « cheat sheet »

Vous trouverez sur internet pléthore de mémento RegEx en une page. Je ne vais donc pas refaire ce qui a été déjà bien fait. par contre voici quelques liens utiles pour retrouver ces informations :

C’est loin d’être exhaustif, une simple recherche via votre moteur de recherche préféré vous le montrera

Les outils indispensables

Comme je l’ai mentionné plus haut les expressions régulières ça se pratique. En fait ça se teste ! pour être plus précis on passe souvent son temps à ajuster ses RegEx. Sans outillage et via une « approche à taton » on peut passer/perdre des heures à trouver la bonne recette.

Il faut donc utiliser des outils qui nous permettrons de tester et « débugger » nos expressions régulières. en voici quelques uns (gratuits et accessibles facilement sur le net):

regex101

Accessible sur https://regex101.com/

Un outil très pratique avec surlignage pour mieux comprendre ce qui se passe, une aide intégrée et bien sur une visualisation des résultats en direct (lors de la frappe). L’outil fournit même le code (Python, Java, etc.) qui correspond si vous lui demandez. De même une librairie de Regex déjà prêtes à l’emploi est disponible. Bref, un super outil !

debuggex

Accessible sur https://www.debuggex.com/

Un outil très pratique avec une approche légèrement différente car graphique et quelque part plus interactive. En gros le schéma du dessus montre la décomposition de votre RegEx ce qui la rend plus visuelle (très pratique pour de très grosses expressions régulières). Très utiles aussi le « slider » du dessous qui permet de balader le curseur de la chaîne.

D’autres outils

En fait il existe vraiment beaucoup d’outils pour tester les expressions régulières, je ne citerais que ceux-ci en plus :

Quelques exemples utiles

Vérifier un email (en minuscule) :

\b[a-z0-9._%+-][email protected][a-z0-9.-]+\.[a-z]{2,}\b

Contrôler le format d’une adresse IP:

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

Vérifier un numéro de carte VISA (attention cette RegEx ne fonctionne que pour VISA, et pas Mastercard par exemple):

^4[0-9]{12}(?:[0-9]{3})?$

Vérifier qu’un mot de passe répond à certains critères (1 lettre, 1 chiffre, 1 caractère spécial au moins Chaîne comprise entre 8 et 15 caractères) :

^(?=.*[A-Za-z])(?=.*\d)(?=.*[&-+!*[email protected]%_])([&-+!*[email protected]%_\w]{8,15})$

Utilisation avec Python

Pour utiliser des RegEx avec Python, rien de plus simple il suffit d’utiliser le module re (import re). Dans l’exemple ci-dessous on récupèrera par exemple deux éléments (groupes) à partir d’une chaîne :

import re

regex = r"([A-Z])([0-9]*)"
matches = re.finditer(regex, "A122 Z3")

for matchNum, match in enumerate(matches, start=1):
    print ("N° de groupe: {matchNum} | {start}-{end}: chaine {match}".format(matchNum = matchNum, start = match.start(), end = match.end(), match = match.group()))
    for groupNum in range(0, len(match.groups())):
        groupNum = groupNum + 1
        print ("Element {groupNum} trouvé: {start}-{end}: {group}".format(groupNum = groupNum, start = match.start(groupNum), end = match.end(groupNum), group = match.group(groupNum)))

Résultat :

N° de groupe: 1 | 0-4: chaine A122
Element 1 trouvé: 0-1: A
Element 2 trouvé: 1-4: 122
N° de groupe: 2 | 5-7: chaine Z3
Element 1 trouvé: 5-6: Z
Element 2 trouvé: 6-7: 3

Utilisation avec Java

En java ce n’est gère plus compliqué car on va utiliser le package regex (java.util.regex..*) qui nous rend la vie tout aussi simple :

import java.util.regex.Matcher;
import java.util.regex.Pattern;

final Pattern pattern = Pattern.compile("([A-Z])([0-9]*)", Pattern.MULTILINE);
final Matcher matcher = pattern.matcher("A122 Z3");

while (matcher.find()) {
    System.out.println("Trouvé: " + matcher.group(0));
    for (int i = 1; i <= matcher.groupCount(); i++) {
        System.out.println("Group " + i + ": " + matcher.group(i));
    }
}


A propos de Benoit Cayla

En plus d'être un spécialiste des données, j'aime passer le plus clair de mon temps à l'extérieur, à jardiner par exemple ou simplement à aller dans le bois avec mes enfants. J'aime aussi le VTT que je pratique chaque semaine avec mes amis. Quand je dois rester à l'intérieur, j'aime améliorer ma maison. Bricoler me permet ainsi de libérer ma créativité ;-). Si je n'ai rien à réparer ou créer, je passe mon temps libre à explorer les dernières avancées technologiques dans le monde de l'IA et du RPA.

Laissez un commentaire

Votre adresse de messagerie ne sera pas publiée.

un × quatre =

Ce site utilise Akismet pour réduire les indésirables. En savoir plus sur comment les données de vos commentaires sont utilisées.