Introduction.
Les expressions régulières sont des outils de l'informatique théorique permettant de décrire les langages de manière formelle.
Elles sont implémentées dans beaucoup de langages de programmation dont Perl qui les utilisent avec une syntaxe étendue (fonction, code dans l'expression régulière, ...).
Ce chapitre peut vous être utile peu importe quel langage vous avez l'habitude de manipuler ou que vous utiliserez à l'avenir.
N'hésitez pas à lire ce chapitre en plusieurs fois pour apprécier toutes les subtilités et pour comprendre à quel point ceci fait partie intégrante du langage Perl et comment bien se servir de ces outils.
Définition.
Une expression régulière est une manière de manipuler du texte de façon concise et claire à l'aide de motifs.
Les expressions régulières (ou « rationnelles », aussi appelées « regex » pour « regular expression ») sont issues des théories mathématiques sur les langages formels.
Format.
Tout d'abord, nous utilisons le symbole "=~" pour utiliser des expressions régulières, ensuite nous avons toute une panoplie de fonctionnalités à appliquer sur un texte (recherche, remplacement…), avec des options disponibles.
Pour cela, voici la syntaxe : 
 $texte =~ "fonction_voulue/première zone de texte[/seconde zone de texte si la fonction voulue le requiert]/[options]";
Pour rappel, ce qui est entre crochets "[]" n'est pas toujours obligatoire.
Le remplacement de texte par exemple nécessitera de rechercher du texte (première zone de texte) puis de le remplacer par un autre texte (seconde zone de texte).
Pour la recherche de texte, pas besoin d'indiquer la seconde zone.
"À savoir" : cet exemple utilise des slashs (/) cependant nous pouvons utiliser d'autres caractères, comme l'underscore, un point d'exclamation, ou encore des accolades par exemple.
Ceci est pratique lorsque nous avons à chercher un motif contenant des slashs (pas besoin de le banaliser, c'est à dire rajouter un antislash « \ » devant le caractère).
Exemple.
Un exemple simple d'utilisation serait de chercher un mot dans un texte, fonctionnalité "m" ("Match" en anglais) :
my $texte = "J'aime le fromage";
if( $texte =~ m/fromage/ ) # on n'utilise pas d'options
 say "On a trouvé « fromage » dans le texte";
else
 say "On n'a pas trouvé de fromage :(";
Comme on peut s'y attendre, ce code va afficher « On a trouvé « fromage » dans le texte » puisque nous recherchons le mot « fromage » dans $texte.
En fait, la fonction cherche à savoir si le texte correspond ("match" en anglais) au motif spécifié.
Celui-ci ne contenant pas d'ancre de début ou fin de texte, peut correspondre avec une partie se trouvant au milieu du texte.
Fonctionnalités.
Nous allons faire un tour des fonctionnalités (que j'appellerai également modes) les plus utilisés.
recherche : m.
Pour effectuer des recherches dans une chaîne de caractère, nous utilisons la fonctionnalité "m".
C'est le mode par défaut, nous n'avons pas besoin de l'écrire.
use strict;
@tableau = ("affiche", "âme", "à toi", " affiche");
print 'Test sur la regex : if ( $texte =~ m/^a/ )'."\n";
foreach my $texte (@tableau){
 print "“$texte“";
print "(espace en-tête)";
print "\n" x 2;
@tableau = ("affiche", "affiche.", "affiches");
print 'Test sur la regex : if ( $texte =~ m/che.$/ )'."\n";
foreach my $texte (@tableau){
 print "“$texte“";
print "\n" x 2;
@tableau = ("affiche", "affiche.", "affiches");
print 'Test sur la regex : if ( $texte =~ m/che\.$/ )'."\n";
foreach my $texte (@tableau){
 print "“$texte“";
print '(\. point échappé = vrai point, pas n‘importe quel caractère)';
print "\n" x 2;
@tableau = qw(tttrès hutte haute hausse tousse);
print 'Test sur la regex : if ( $texte =~ m/[t]{1,2}/ )'."\n";
foreach my $texte (@tableau){
 print "“$texte“";
print "\n";
remplacement : s.
Le mode "s" permet d'effectuer un remplacement (aussi appelé substitution) dans une chaîne.
Ici, nous avons besoin d'utiliser les deux zones de textes, de cette manière : codice_1 .
exemple de substitution.
my $texte = "J'aime le fromage.";
$texte =~ s/le fromage/les légumes/; # les légumes c'est plus sain que le fromage !
say $texte; # affiche « J'aime les légumes. »
stocker une expression régulière : qr.
my $regex_mail = qr{[\w-+.]+@[\w-]+(?:\.[\w-]+)+};
unless ("nom@example.com" =~ /$regex_mail/) {
 say "Ce n'est pas une adresse mail";
constructeurs spéciaux :.
?= préviseur positif (positive lookahead).
use strict;
my $texte = "anticonstitutionnellement";
$texte =~ /(ti(?=on).+)/;# 
print $1."\n"; # tionnellement
$texte =~ /(ti(?=tu).+)/;# 
print $1."\n"; # titutionnellement
?! préviseur négatif (negative lookahead).
use strict;
my $texte = "anticonstitutionnellement";
$texte =~ /(ti(?!on).+)/;# 
print $1."\n"; # ticonstitutionnellement
$texte =~ /(ti(?!cons).+)/;# 
print $1."\n"; # titutionnellement
?<= rétroviseur positif (positive lookbehind).
use strict;
$texte = "anticonstitutionnellement";
$texte =~ /(.+(?<=tu)ti)/;#
print $1."\n"; # anticonstituti
$texte =~ /(.+(?<=an)ti)/;#
print $1."\n"; # anti
?<! rétroviseur négatif (negative lookbehind).
use strict;
$texte = "anticonstitutionnellement";
$texte =~ /(.+(?<!tu)ti)/;#
print $1."\n"; # anticonsti
$texte =~ /(.+(?<!an)ti)/;#
print $1."\n"; # anticonstituti
?> constructeur tête de mule !
Attrape la chaîne correspondante maximale où il est ancré, et refuse de faire un pas en arrière
( pas de backtracking pour trouver toutes les sous-chaînes ).
use strict;
my $count=0;
my $texte="a"x 33 ."b";
$texte =~ /(a+b?)(?{print "$&\n"; $count++})(*FAIL)/;
print "Count=$count\n"; # 594
$count=0;
$texte =~ /(?>(a+b?))(?{print "$&\n"; $count++})(*FAIL)/;
print "Count=$count\n"; # 33
 Sert à l'optimisation :
Pour 2 000 "a", on attend 2 003 000 recherches (sans ?>) contre 2 000 seulement (avec ?>).
Correspondances.
Lors d'une recherche de motif, nous pouvons utiliser des caractères spéciaux (parfois appelés « méta-caractères ») pour rechercher un type de caractère (et non un caractère explicitement).
caractères et expressions de correspondance.
caractère quelconque : ..
Le point « . » correspond à un caractère quelconque.
Lors d'une recherche, nous pouvons l'utiliser pour indiquer n'importe quel caractère, excepté le retour à la ligne (\n).
exemple utilisation du point.
use strict;
my @tableau = qw(matin mâtin méthode admit);
print 'Test sur la regex : if ( $texte =~ m/m.t/ )'."\n";
foreach my $texte (@tableau){
 print "“$texte“";
print "(lettres accentuées = 2 octets)";
print "\n" x 2;
@tableau = qw(matin mâtin méthode admit);
print 'Test sur la regex : if ( $texte =~ m/m..t/ )'."\n";
foreach my $texte (@tableau){
 print "“$texte“";
print "\n";
caractère alphabétique :.
Pour rechercher un caractère alphabétique on utilise: ou éventuellement [a-zA-Z].
use strict;
my @tableau = qw(satin 264 mâtin àâéèêëîôùûæœç àâéèêëîôùûæœça);
print 'regex : if ( $texte =~ m// )'."\n";
foreach my $texte (@tableau){
 print "“$texte“";
print '(voyelles accentuées non ASCII)';
print "\n";
caractère numérique : \d et.
Nous avons deux possibilités pour rechercher un caractère numérique : et \d.
Pour chercher un caractère qui n'est "pas" un chiffre : \D.
use strict;
my @tableau = qw(satin 264 37.5lematin àâ68éèêëîôùûæœç);
print 'regex : if ( $texte =~ m// )'."\n";
foreach my $texte (@tableau){
 print "“$texte“";
print "\n";
caractère hexadécimal :.
Cela correspond à tout caractère hexadécimal, c'est à dire tous les caractères numériques (de 0 à 9) et les lettres de A à F.
use strict;
my @tableau = qw(sAtin DEBAClE 0123456789ABCDEF abcdef ghijkl);
print 'regex : if ( $texte =~ m// )'."\n";
foreach my $texte (@tableau){
 print "“$texte“";
print "\n";
caractère alphanumérique : et \w.
Les caractères alphanumériques correspondent à l'ensemble des caractères numériques (0,1,2…) et aux lettres. La classe \w reconnaît, en plus de , le caractère «_». Pour chercher un caractère qui n'est "pas" un nombre ou une lettre ou «_» : \W.
use strict;
my @tableau = qw(&§@$£()[]{}#°%_ sAtin 0123456789ABCDEF §ghijkl);
print 'regex : if ( $texte =~ m/\W/ )'."\n";
foreach my $texte (@tableau){
 print "“$texte“";
print "\n";
caractère d'espacement simple :.
Un espacement correspond à un espace, une tabulation.
use strict;
my @tableau = ( "ça va?", "tab ulation","tabulation"," vu!");
print 'regex : if ( $texte =~ m// )'."\n";
foreach my $texte (@tableau){
 print "“$texte“";
print "\n";
caractère d'espacement quelconque : \s et.
On cherche ici un espacement tel qu'une tabulation, un espace, un saut de ligne ou de page.
Pour chercher un caractère qui n'est "pas" un espacement : \S.
use strict;
my @tableau = ( " ", " ","t "," v");
print 'regex : if ( $texte =~ m/\S/ )'."\n";
foreach my $texte (@tableau){
 print "“$texte“";
print "\n";
lettre en minuscule :.
use strict;
my @tableau = qw( ABCDE ABCdE);
print 'regex : if ( $texte =~ m// )'."\n";
foreach my $texte (@tableau){
 print "“$texte“";
print "\n";
lettre en majuscule :.
use strict;
my @tableau = qw( abcde abcDe);
print 'regex : if ( $texte =~ m// )'."\n";
foreach my $texte (@tableau){
 print "“$texte“";
print "\n";
correspondances partielles : [].
Nous cherchons une correspondance avec uniquement une partie des caractères, nous utilisons alors "[]".
Nous pouvons choisir d'énumérer explicitement tous les caractères dont nous souhaitons vérifier la correspondance en les écrivant entre ces crochets.
Un moyen plus répandu (lorsque cela est possible) est d'utiliser une suite de caractères, par exemple de « a » à « z » de cette manière : [a-z].
Pour correspondre avec l"'inverse" de ce qu'on note entre crochets, il suffit de mettre en première lettre « ^ ».
Ainsi, la recherche inverse de l'exemple précédent devient : [^a-z].
exemple de correspondance partielle.
Cherchons à faire correspondre uniquement les caractères de « a » à « e » en minuscule, de « G » à « L » en majuscule et les chiffres de « 0 » à « 5 » et les chiffres 7 et 9.
$texte =~ /[a-eG-K0-579]/;
crochets []
use strict;
@tableau = qw(affiche affole affuble affriole effectué effacer);
print 'Test sur la regex : if ( $texte =~ m/ff[a-df-np-s]/ )'."\n";
foreach my $texte (@tableau){
 print "“$texte“";
print "\n";
crochets [^…]
use strict;
@tableau = qw(affiche affole affuble affriole effectué effacer);
print 'Test sur la regex : if ( $texte =~ m/ff[^ieo]/ )'."\n";
foreach my $texte (@tableau){
 print "“$texte“";
print "\n";
Options.
ignorer la casse.
La « casse » désigne en informatique la différence entre minuscule et majuscule.
Si on choisi d'ignorer la casse, alors nous recherchons un motif sans distinction avec ou sans majuscules. Pour cela nous avons l'option "i".
recherche en mode multi-ligne.
Nous recherchons un motif en traitant la chaîne en tant que constituée de plusieurs lignes. Concrètement, nous voulons que ^ et $ ne correspondent pas seulement au début et fin de la chaîne, mais aussi au début et fin de chaque ligne. Pour cela, nous avons l'option "m".
exemple de recherche en mode multi-ligne.
my $texte = "Ce texte
est sur
plusieurs lignes";
if( $texte =~ m/sur$/m ) 
 say "On a trouvé « sur » en fin de ligne";
else
 say "On n'a pas trouvé « sur » en fin de ligne";
faire correspondre . à un saut de ligne.
Lorsque nous faisons des recherches sur plusieurs lignes, on souhaiterait pouvoir considérer le saut de ligne comme un caractère quelconque (comme tous les autres).
Nous pouvons faire cela avec l'option "s".
exemple utilisation de l'option s.
Nous reprenons l'exemple précédent avec la recherche sur plusieurs lignes, désormais nous n'avons pas à écrire explicitement le saut de ligne, nous pouvons utiliser le métacaractère ".".
my $texte = "Ce texte
est sur
plusieurs lignes";
if( $texte =~ m/sur.plusieurs/s ) 
 say "On a trouvé « sur plusieurs » dans le texte";
else
 say "On n'a pas trouvé « sur plusieurs »";
permettre d'écrire l'expression régulière avec des commentaires.
L'option « x » permet d'écrire une expression régulière sans tenir compte des caractères d'espacement.
Ainsi, on peut espacer ses expressions avec des retours à la ligne si on veut, sans que cela n'influe sur votre expression.
Si vous souhaitez rechercher une chaîne de caractères avec des espaces à certains endroits, il faudra l'indiquer explicitement dans votre expression avec la recherche d'un caractère d'espacement (voir plus haut).
appliquer un changement plusieurs fois dans la chaîne.
Lors de la substitution de texte, nous souhaiterions par exemple changer tous les caractères « a » par « b ». Par défaut, seule la première occurrence de « a » serait modifiée. Pour changer ce comportement et changer tous les « a », nous utilisons l'option "g".
use strict;
my $texte = "affuble mutin hure mure fumé luit";
 print $texte."\n";
 $texte =~ s/u/a/;
 print $texte;
print "\n" x 2;
$texte = "affuble mutin hure mure fumé luit";
 print $texte."\n";
 $texte =~ s/u/a/g ;
 print $texte;
print "\n";
cumuler les options.
Nous pouvons additionner les options en les écrivant à la suite (/ig par exemple).
Nous avons déjà vu un exemple plus haut en cumulant les options "m" (recherche de motif sur plusieurs lignes) et "s" (retour chariot inclut dans les caractères auxquels le point correspond).
Autre exemple, nous pouvons effectuer une substitution plusieurs fois par ligne en ignorant la casse du motif à remplacer.
Ancres.
Les ancres correspondent au placement du texte à rechercher.
rechercher en début de chaîne : ^ et \A.
On utilise pour cela le caractère "^" ou \A qui correspond au début de la chaîne.
Avec l'option /m le caractère "^" correspond également à tout début de ligne (voir plus haut).
exemple de recherche en début de chaîne.
my $texte = "Hello world!";
$texte =~ /world/ ; # correspond
$texte =~ /^world/ ; # ne correspond pas car « world » n'est pas au début de la chaîne
^ début de ligne
use strict;
@tableau = ("affiche", "âme", "à toi", " affiche");
print 'regex : if ( $texte =~ m/^a/ )'."\n";
foreach my $texte (@tableau){
 print "“$texte“";
print "(espace en-tête)";
print "\n";
rechercher en fin de chaîne : $, \Z et \z.
$ est l'analogue de ^ mais en fin de chaîne (ou de ligne aussi avec option "m").
\z est l'analogue de A en fin de chaîne, donc non affecté par l'option "m". \Z est comme \z mais peut correspondre aussi à un retour à la ligne en fin de chaîne.
exemple de recherche en fin de chaîne.
my $texte = "Hello world!";
$texte =~ /Hello/ ; # correspond
$texte =~ /Hello$/ ; # ne correspond pas car « Hello » n'est pas en fin de chaîne
$ fin de ligne
use strict;
@tableau = ("affiche", "affiche.", "affiches");
print 'regex : if ( $texte =~ m/che.$/ )'."\n";
foreach my $texte (@tableau){
 print "“$texte“";
print "\n";
Quantification.
Nous allons aborder maintenant la partie concernant l'identification d'un motif se répétant.
exemple d'introduction au quantifications.
Avant de commencer, il faut se confronter au problème.
Nous avons une chaîne de caractères, et nous souhaitons savoir si elle contient deux fois le caractère « a ».
Vu l'étendue des connaissances acquises jusque-là, nous devrions résoudre le problème comme suit :
$texte =~ /aa/; # si $texte contient 2 fois le caractère « a » il correspondra
Maintenant, on souhaite savoir si la chaîne de caractères contient deux fois le caractère « a » (jusque-là, le problème reste identique) sauf que ces deux caractères peuvent être séparés par un caractère quelconque (ou pas).
Là encore, vu l'étendue des connaissances acquises actuellement, cela donnerait : 
if( $texte =~ /aa/ || $texte =~ /a.a/) # pas de caractère séparateur ou un seul
 ... # si ça correspond, on fait quelque chose
Nous résolvons le problème ici assez facilement, mais qu'en est-il si nous cherchons deux fois le caractère « a » avec un nombre quelconque de caractères séparateurs ?
Impossible actuellement.
Quantifier par un nombre : {}.
Nous avons une chaîne de caractères, et nous recherchons un motif quelconque se répétant un certain nombre de fois.
Nous pouvons expliciter ce nombre de fois, ou simplement donner une tranche : 
exemples avec : {}.
my $texte = "coucou!";
$texte =~ /c.{2}c/ ; # correspond
$texte =~ /c.{1,3}c/ ; # correspond
$texte =~ /cou{2}/ ; # ne correspond pas !
$texte =~ /c.{1,}c/ ; # correspond
Ligne 2 : il y a correspondance car nous avons précisément deux caractères séparant les deux lettres « c ».
Ligne 3 : il y a correspondance là aussi, car il y a un nombre compris entre 1 et 3 caractères entre les deux lettres « c ».
"Attention" : ligne 4 ne correspond pas car il faudrait qu'il y ait 2 lettres « u » consécutives et non toute la chaîne « cou » !
Nous verrons plus tard comment procéder pour faire cela.
Enfin, ligne 5 correspond car on cherche « au moins » un caractère entre deux « c ».
Entre 0 ou 1 occurrence : ?
Il est possible que le caractère (ou plus généralement le motif) soit présent ou non.
On utilise pour cela le quantificateur "?".
use strict;
@tableau = qw(pommes pomme mess);
print 'Test sur la regex : if ( $texte =~ m/me[s]?$/ )'."\n";
foreach my $texte (@tableau){
 print "“$texte“";
print "\n";
Entre 0 ou un nombre non déterminé d'occurrences : *.
Quand il peut y avoir 0 ou une infinité d'occurrences d'un motif, on utilise le caractère spécial " * ".
use strict;
@tableau = qw(miss mess messe messes);
print 'Test sur la regex : if ( $texte =~ m/e[s]*$/ )'."\n";
foreach my $texte (@tableau){
 print "“$texte“";
print "\n" x 2;
@tableau = qw(pomme pommes mess messe messes);
print 'Test sur la regex : if ( $texte =~ m/e[s]+$/ )'."\n";
foreach my $texte (@tableau){
 print "“$texte“";
print "\n";
Capturer du texte.
La capture du texte (d'un certain motif) permet de réutiliser ce texte pour le replacer (en le modifiant éventuellement).
Simple capture de texte : ().
Nous souhaitons prendre une partie du texte pour le réutiliser. 
Lorsque vous capturez du texte, les variables $1, $2 … sont mises à jour avec la capture que vous venez de faire entre parenthèses.
Ainsi, le premier groupe capturé par () pourra être réutilisé dans votre code via la variable $1, le second avec la variable $2 et ainsi de suite jusqu'à $9.
use strict;
@tableau = qw(dare-dare borborigme calcul barbare Tartare bébé );
print 'Test sur la regex : if ( $texte =~ m/(...)\1/ )'."\n";
foreach my $texte (@tableau){
 print "“$texte“";
print "(é = 2 octets)";
print "\n";
Ne pas capturer le motif : (?:).
my $texte = "J'aime le fromage";
$texte =~ m/(?:aime).*(fromage)/;
say $1; # affiche "fromage"
use strict;
my $texte = "je chante, tu chantes, il chante, nous chantons, vous chantez, ils chantent";
 print $texte."\n";
 $texte =~ s/(\w+) (?:\w+)(\w), (\w+) (?:\w+)(\w{2}), (\w+) (?:\w+)(\w), (\w+) (?:\w+)(\w{3}), (\w+) (?:\w+)(\w{2}), (\w+) (?:\w+)(\w{3})/$1_$2 $3_$4 $5_$6 $7_$8 $9_$10 $11_$12/;
 print $texte."\n";
print "\n" x 2;
Réutiliser les motifs capturés : \1 \2 ….
my $texte = "J'aime le le fromage"; # doublon «le»
$texte =~ s/(\w+) \1/$1/g;
my $texte = "chanter - verbe du 1e groupe - e es e ons ez ent";
 print $texte."\n";
 $texte =~ s/(\w+)(..) (?:-.*-) (\w+) (\w+) \3 (\w+) (\w+) (\w+)/je $1$3, tu $1$4, il $1$3, nous $1$5, vous $1$6, ils $1$7./;
 print $texte."\n";
print "\n";
Définir des alternatives : (a|b).
use strict;
my @tableau = qw(satin malin matin calin);
print 'regex : if ( $texte =~ m/m|t/ )'."\n";
foreach my $texte (@tableau){
 print "“$texte“";
print "\n";
Captures avides ou non avides.
Le plus simple pour comprendre ce qu'est une capture avide est de prendre un exemple.
capture avide.
exemple 1 de capture avide.
Soit la capture « (c+) » qui va prendre une fois ou un nombre non limité de fois la lettre « c ».
$texte = "cccccc";
$texte =~ /^(c+)/;
say $1;
Si vous exécutez ce code, vous verrez affiché « cccccc » et non pas un seul « c ».
Cela est dû à l'avidité (en anglais greedy) des opérateurs.
exemple 2 de capture avide.
Un autre exemple, un peu plus complexe, pour bien comprendre le phénomène, qui peut s'avérer gênant : nous avons une chaîne de caractères avec des champs délimités par des doubles points « : » :
$texte = "nom:prenom:age:date/de/naissance";
$texte =~ /^(.+):/; # .+ : on récupère le maximum de caractères avant de tomber sur un double points
say $1;
Ici, nous affichons le nom, le prénom et l'âge, car nous prenons la chaîne la plus longue possible correspondant à notre expression.
C'est à dire, la chaîne la plus longue se terminant par un double point.
capture non avide.
Maintenant, ce qu'on voudrait c'est de ne prendre que la plus petite partie possible qui correspond à notre expression régulière.
La solution est de remplacer chaque quantificateur par sa version non avide : 
use strict;
my $texte = "anticonstitutionnellement";
$texte =~ /^(.+)i/;
print $1."\n"; # anticonstitut
$texte =~ /^(.+?)i/;
print $1."\n"; # ant
$texte =~ /^(.{6,})e/;
print $1."\n"; # anticonstitutionnellem
$texte =~ /^(.{6,}?)e/;
print $1."\n"; # anticonstitutionn
= Les coulisses des regex =
@+ et @- les @rchiveurs de regex.
@+ matrice des fins des chaînes trouvées ($+[0] fin globale, $+[1] fin de $1 …)
@- matrice des débuts des chaînes
Les items de @+ ne se notent pas @+[0], @+[1] … mais $+[0], $+[1] … car ce sont des scalaires.
use strict;
my $texte = "anticonstitutionnellement";
$texte =~ m/(cons...).*(nne).*(ll)/;
print "$1 $2 $3\n" ; # constitu nne ll
print substr($texte,0,$-[0])." ".substr($texte,$-[0],$+[0]-$-[0])." ".substr($texte, $+[0])."\n";
print $-[2]." ".$+[2]."\n"; # 15 18 : début & fin de "nne"
print "@+\n"; # 20 12 18 20
print "@-\n"; # 4 4 15 18