Perl - Expressions régulières

Une expression régulière est une chaîne de caractères qui définit le ou les modèles que vous visualisez. La syntaxe des expressions régulières en Perl est très similaire à ce que vous trouverez dans d'autres programmes d'expressions régulières, tels quesed, grep, et awk.

La méthode de base pour appliquer une expression régulière consiste à utiliser les opérateurs de liaison de modèle = ~ et !~. Le premier opérateur est un opérateur de test et d'affectation.

Il existe trois opérateurs d'expressions régulières dans Perl.

• Faire correspondre l'expression régulière - m //
• Remplacer une expression régulière - s ///
• Expression régulière translittération - tr ///

Les barres obliques dans chaque cas agissent comme des délimiteurs pour l'expression régulière (regex) que vous spécifiez. Si vous êtes à l'aise avec un autre délimiteur, vous pouvez l'utiliser à la place de la barre oblique.

L'opérateur de match

L'opérateur de correspondance, m //, est utilisé pour faire correspondre une chaîne ou une instruction à une expression régulière. Par exemple, pour faire correspondre la séquence de caractères "foo" avec le scalaire $ bar, vous pouvez utiliser une instruction comme celle-ci -

#!/usr/bin/perl

$bar = "This is foo and again foo";
if ($bar =~ /foo/) {
   print "First time is matching\n";
} else {
   print "First time is not matching\n";
}

$bar = "foo";
if ($bar =~ /foo/) {
   print "Second time is matching\n";
} else {
   print "Second time is not matching\n";
}

Lorsque le programme ci-dessus est exécuté, il produit le résultat suivant -

First time is matching
Second time is matching

Le m // fonctionne en fait de la même manière que la série d'opérateurs q //. Vous pouvez utiliser n'importe quelle combinaison de caractères naturellement correspondants pour servir de délimiteurs pour l'expression. Par exemple, m {}, m () et m> <sont tous valides. Ainsi, l'exemple ci-dessus peut être réécrit comme suit -

#!/usr/bin/perl

$bar = "This is foo and again foo";
if ($bar =~ m[foo]) {
   print "First time is matching\n";
} else {
   print "First time is not matching\n";
}

$bar = "foo";
if ($bar =~ m{foo}) {
   print "Second time is matching\n";
} else {
   print "Second time is not matching\n";
}

Vous pouvez omettre m de m // si les délimiteurs sont des barres obliques, mais pour tous les autres délimiteurs, vous devez utiliser le préfixe m.

Notez que toute l'expression de correspondance, c'est-à-dire l'expression à gauche de = ~ ou! ~ Et l'opérateur de correspondance, renvoie true (dans un contexte scalaire) si l'expression correspond. Par conséquent, la déclaration -

$true = ($foo =~ m/foo/);

mettra $ true à 1 si $ foo correspond à l'expression régulière, ou à 0 si la correspondance échoue. Dans un contexte de liste, la correspondance renvoie le contenu de toutes les expressions groupées. Par exemple, lors de l'extraction des heures, des minutes et des secondes d'une chaîne de temps, nous pouvons utiliser -

my ($hours, $minutes, $seconds) = ($time =~ m/(\d+):(\d+):(\d+)/);

Match Operator Modifiers

L'opérateur de correspondance prend en charge son propre ensemble de modificateurs. Le modificateur / g permet une correspondance globale. Le modificateur / i rendra la correspondance insensible à la casse. Voici la liste complète des modificateurs

N ° Sr.	Modificateur et description
1	i Rend la correspondance insensible à la casse.
2	m Spécifie que si la chaîne contient des caractères de retour à la ligne ou de retour chariot, les opérateurs ^ et $ correspondent désormais à une limite de nouvelle ligne, au lieu d'une limite de chaîne.
3	o Évalue l'expression une seule fois.
4	s Permet l'utilisation de. pour correspondre à un caractère de nouvelle ligne.
5	x Vous permet d'utiliser un espace blanc dans l'expression pour plus de clarté.
6	g Recherche globalement toutes les correspondances.
sept	cg Permet à la recherche de continuer même après l'échec d'une correspondance globale.

Correspondance une seule fois

Il existe également une version plus simple de l'opérateur de correspondance - le? PATTERN? opérateur. C'est fondamentalement identique à l'opérateur m // sauf qu'il ne correspond qu'une seule fois dans la chaîne que vous recherchez entre chaque appel à réinitialiser.

Par exemple, vous pouvez utiliser ceci pour obtenir le premier et le dernier éléments d'une liste -

#!/usr/bin/perl

@list = qw/food foosball subeo footnote terfoot canic footbrdige/;

foreach (@list) {
   $first = $1 if /(foo.*?)/;
   $last = $1 if /(foo.*)/;
}
print "First: $first, Last: $last\n";

Lorsque le programme ci-dessus est exécuté, il produit le résultat suivant -

First: foo, Last: footbrdige

Variables d'expression régulière

Les variables d'expression régulière incluent $, qui contient tout ce que la dernière correspondance de regroupement correspond; $&, qui contient toute la chaîne correspondante; $`, qui contient tout avant la chaîne correspondante; et$', qui contient tout après la chaîne correspondante. Le code suivant montre le résultat -

#!/usr/bin/perl

$string = "The food is in the salad bar";
$string =~ m/foo/;
print "Before: $`\n";
print "Matched: $&\n";
print "After: $'\n";

Lorsque le programme ci-dessus est exécuté, il produit le résultat suivant -

Before: The
Matched: foo
After: d is in the salad bar

L'opérateur de substitution

L'opérateur de substitution, s ///, n'est en réalité qu'une extension de l'opérateur de correspondance qui vous permet de remplacer le texte correspondant par un nouveau texte. La forme de base de l'opérateur est -

s/PATTERN/REPLACEMENT/;

Le PATTERN est l'expression régulière du texte que nous recherchons. Le REMPLACEMENT est une spécification du texte ou de l'expression régulière que nous voulons utiliser pour remplacer le texte trouvé par. Par exemple, nous pouvons remplacer toutes les occurrences dedog avec cat en utilisant l'expression régulière suivante -

#/user/bin/perl

$string = "The cat sat on the mat";
$string =~ s/cat/dog/;

print "$string\n";

Lorsque le programme ci-dessus est exécuté, il produit le résultat suivant -

The dog sat on the mat

Modificateurs d'opérateurs de substitution

Voici la liste de tous les modificateurs utilisés avec l'opérateur de substitution.

N ° Sr.	Modificateur et description
1	i Rend la correspondance insensible à la casse.
2	m Spécifie que si la chaîne contient des caractères de retour à la ligne ou de retour chariot, les opérateurs ^ et $ correspondent désormais à une limite de nouvelle ligne, au lieu d'une limite de chaîne.
3	o Évalue l'expression une seule fois.
4	s Permet l'utilisation de. pour correspondre à un caractère de nouvelle ligne.
5	x Vous permet d'utiliser un espace blanc dans l'expression pour plus de clarté.
6	g Remplace toutes les occurrences de l'expression trouvée par le texte de remplacement.
sept	e Évalue le remplacement comme s'il s'agissait d'une instruction Perl et utilise sa valeur de retour comme texte de remplacement.

L'opérateur de traduction

La traduction est similaire, mais pas identique, aux principes de substitution, mais contrairement à la substitution, la traduction (ou translittération) n'utilise pas d'expressions régulières pour sa recherche sur les valeurs de remplacement. Les opérateurs de traduction sont -

tr/SEARCHLIST/REPLACEMENTLIST/cds
y/SEARCHLIST/REPLACEMENTLIST/cds

La traduction remplace toutes les occurrences des caractères dans SEARCHLIST par les caractères correspondants dans REPLACEMENTLIST. Par exemple, en utilisant le "Le chat s'est assis sur le tapis." chaîne que nous avons utilisée dans ce chapitre -

#/user/bin/perl

$string = 'The cat sat on the mat';
$string =~ tr/a/o/;

print "$string\n";

Lorsque le programme ci-dessus est exécuté, il produit le résultat suivant -

The cot sot on the mot.

Des plages Perl standard peuvent également être utilisées, vous permettant de spécifier des plages de caractères par lettre ou valeur numérique. Pour changer la casse de la chaîne, vous pouvez utiliser la syntaxe suivante à la place deuc fonction.

$string =~ tr/a-z/A-Z/;

Modificateurs d'opérateurs de traduction

Voici la liste des opérateurs liés à la traduction.

N ° Sr.	Modificateur et description
1	c Complète la LISTE DE RECHERCHE.
2	d Supprime les caractères trouvés mais non remplacés.
3	s Les écrasements dupliquent les caractères remplacés.

Le modificateur / d supprime les caractères correspondant à SEARCHLIST qui n'ont pas d'entrée correspondante dans REPLACEMENTLIST. Par exemple -

#!/usr/bin/perl 

$string = 'the cat sat on the mat.';
$string =~ tr/a-z/b/d;

print "$string\n";

Lorsque le programme ci-dessus est exécuté, il produit le résultat suivant -

b b   b.

Le dernier modificateur, / s, supprime les séquences de caractères en double qui ont été remplacées, donc -

#!/usr/bin/perl

$string = 'food';
$string = 'food';
$string =~ tr/a-z/a-z/s;

print "$string\n";

Lorsque le programme ci-dessus est exécuté, il produit le résultat suivant -

fod

Expressions régulières plus complexes

Vous n'avez pas seulement besoin de faire correspondre des chaînes fixes. En fait, vous pouvez faire correspondre à peu près tout ce dont vous pourriez rêver en utilisant des expressions régulières plus complexes. Voici une feuille de triche rapide -

Le tableau suivant répertorie la syntaxe d'expression régulière disponible en Python.

N ° Sr.	Modèle et description
1	^ Correspond au début de la ligne.
2	$ Correspond à la fin de la ligne.
3	. Correspond à n'importe quel caractère unique sauf le saut de ligne. L'utilisation de l'option m lui permet également de correspondre à la nouvelle ligne.
4	[...] Correspond à n'importe quel caractère unique entre crochets.
5	[^...] Correspond à tout caractère unique non entre crochets.
6	* Correspond à 0 occurrences ou plus de l'expression précédente.
sept	+ Correspond à une ou plusieurs occurrences de l'expression précédente.
8	? Correspond à 0 ou 1 occurrence de l'expression précédente.
9	{ n} Correspond exactement au nombre n d'occurrences de l'expression précédente.
dix	{ n,} Correspond à n occurrences ou plus de l'expression précédente.
11	{ n, m} Correspond à au moins n et au plus m occurrences de l'expression précédente.
12	a| b Correspond à a ou b.
13	\w Correspond aux caractères des mots.
14	\W Correspond aux caractères non-mots.
15	\s Correspond aux espaces. Équivaut à [\ t \ n \ r \ f].
16	\S Correspond à un espace non blanc.
17	\d Correspond aux chiffres. Équivalent à [0-9].
18	\D Correspond aux non-chiffres.
19	\A Correspond au début de la chaîne.
20	\Z Correspond à la fin de la chaîne. Si une nouvelle ligne existe, elle correspond juste avant la nouvelle ligne.
21	\z Correspond à la fin de la chaîne.
22	\G Correspond au point où le dernier match s'est terminé.
23	\b Correspond aux limites des mots en dehors des crochets. Correspond à l'espace arrière (0x08) lorsqu'il est entre crochets.
24	\B Correspond aux limites non-mot.
25	\n, \t, etc. Correspond aux retours à la ligne, aux retours chariot, aux tabulations, etc.
26	\1...\9 Correspond à la nième sous-expression groupée.
27	\10 Correspond à la nième sous-expression groupée si elle correspond déjà. Sinon, fait référence à la représentation octale d'un code de caractère.
28	[aeiou] Correspond à un seul caractère dans l'ensemble donné
29	[^aeiou] Correspond à un seul caractère en dehors de l'ensemble donné

Le métacaractère ^ correspond au début de la chaîne et le symbole $ metasymbole correspond à la fin de la chaîne. Voici quelques brefs exemples.

# nothing in the string (start and end are adjacent)
/^$/   

# a three digits, each followed by a whitespace
# character (eg "3 4 5 ")
/(\d\s) {3}/  

# matches a string in which every
# odd-numbered letter is a (eg "abacadaf")
/(a.)+/  

# string starts with one or more digits
/^\d+/

# string that ends with one or more digits
/\d+$/

Jetons un œil à un autre exemple.

#!/usr/bin/perl

$string = "Cats go Catatonic\nWhen given Catnip";
($start) = ($string =~ /\A(.*?) /);
@lines = $string =~ /^(.*?) /gm;
print "First word: $start\n","Line starts: @lines\n";

Lorsque le programme ci-dessus est exécuté, il produit le résultat suivant -

First word: Cats
Line starts: Cats When

Correspondance des limites

le \bcorrespond à n'importe quelle limite de mot, comme défini par la différence entre la classe \ w et la classe \ W. Parce que \ w inclut les caractères d'un mot, et \ W le contraire, cela signifie normalement la terminaison d'un mot. le\Bl'assertion correspond à toute position qui n'est pas une limite de mot. Par exemple -

/\bcat\b/ # Matches 'the cat sat' but not 'cat on the mat'
/\Bcat\B/ # Matches 'verification' but not 'the cat on the mat'
/\bcat\B/ # Matches 'catatonic' but not 'polecat'
/\Bcat\b/ # Matches 'polecat' but not 'catatonic'

Sélection d'alternatives

Le | caractère est exactement comme le OU standard ou au niveau du bit dans Perl. Il spécifie des correspondances alternatives dans une expression régulière ou un groupe. Par exemple, pour faire correspondre "chat" ou "chien" dans une expression, vous pouvez utiliser ceci -

if ($string =~ /cat|dog/)

Vous pouvez regrouper des éléments individuels d'une expression afin de prendre en charge des correspondances complexes. La recherche des noms de deux personnes pourrait être réalisée avec deux tests distincts, comme celui-ci -

if (($string =~ /Martin Brown/) ||  ($string =~ /Sharon Brown/))

This could be written as follows

if ($string =~ /(Martin|Sharon) Brown/)

Association de regroupement

Du point de vue des expressions régulières, il n'y a pas de différence entre sauf, peut-être, que le premier est légèrement plus clair.

$string =~ /(\S+)\s+(\S+)/;

and 

$string =~ /\S+\s+\S+/;

Cependant, l'avantage du regroupement est qu'il nous permet d'extraire une séquence d'une expression régulière. Les regroupements sont renvoyés sous forme de liste dans l'ordre dans lequel ils apparaissent dans l'original. Par exemple, dans le fragment suivant, nous avons extrait les heures, les minutes et les secondes d'une chaîne.

my ($hours, $minutes, $seconds) = ($time =~ m/(\d+):(\d+):(\d+)/);

En plus de cette méthode directe, les groupes correspondants sont également disponibles dans les variables spéciales $ x, où x est le numéro du groupe dans l'expression régulière. On pourrait donc réécrire l'exemple précédent comme suit -

#!/usr/bin/perl

$time = "12:05:30";

$time =~ m/(\d+):(\d+):(\d+)/;
my ($hours, $minutes, $seconds) = ($1, $2, $3);

print "Hours : $hours, Minutes: $minutes, Second: $seconds\n";

Lorsque le programme ci-dessus est exécuté, il produit le résultat suivant -

Hours : 12, Minutes: 05, Second: 30

Lorsque des groupes sont utilisés dans des expressions de substitution, la syntaxe $ x peut être utilisée dans le texte de remplacement. Ainsi, nous pourrions reformater une chaîne de date en utilisant ceci -

#!/usr/bin/perl

$date = '03/26/1999';
$date =~ s#(\d+)/(\d+)/(\d+)#$3/$1/$2#;

print "$date\n";

Lorsque le programme ci-dessus est exécuté, il produit le résultat suivant -

1999/03/26

L'assertion \ G

L'assertion \ G vous permet de continuer la recherche à partir du point où la dernière correspondance s'est produite. Par exemple, dans le code suivant, nous avons utilisé \ G pour que nous puissions rechercher la bonne position, puis extraire des informations, sans avoir à créer une expression régulière unique plus complexe -

#!/usr/bin/perl

$string = "The time is: 12:31:02 on 4/12/00";

$string =~ /:\s+/g;
($time) = ($string =~ /\G(\d+:\d+:\d+)/);
$string =~ /.+\s+/g;
($date) = ($string =~ m{\G(\d+/\d+/\d+)});

print "Time: $time, Date: $date\n";

Lorsque le programme ci-dessus est exécuté, il produit le résultat suivant -

Time: 12:31:02, Date: 4/12/00

L'assertion \ G n'est en fait que l'équivalent métasymbole de la fonction pos, donc entre les appels d'expression régulière, vous pouvez continuer à utiliser pos, et même modifier la valeur de pos (et donc \ G) en utilisant pos comme sous-programme lvalue.

Exemples d'expressions régulières

Caractères littéraux

N ° Sr.	Exemple et description
1	Perl Correspond à "Perl".

Classes de personnages

N ° Sr.	Exemple et description
1	[Pp]ython Correspond à "Python" ou "python"
2	rub[ye] Correspond à "ruby" ou "rube"
3	[aeiou] Correspond à n'importe quelle voyelle minuscule
4	[0-9] Correspond à n'importe quel chiffre; identique à [0123456789]
5	[a-z] Correspond à n'importe quelle lettre ASCII minuscule
6	[A-Z] Correspond à n'importe quelle lettre ASCII majuscule
sept	[a-zA-Z0-9] Correspond à l'un des éléments ci-dessus
8	[^aeiou] Correspond à tout autre chose qu'une voyelle minuscule
9	[^0-9] Correspond à autre chose qu'un chiffre

Classes de caractères spéciales

N ° Sr.	Exemple et description
1	. Correspond à n'importe quel caractère sauf le saut de ligne
2	\d Correspond à un chiffre: [0-9]
3	\D Correspond à un non-chiffre: [^ 0-9]
4	\s Correspond à un caractère d'espacement: [\ t \ r \ n \ f]
5	\S Correspond aux espaces non blancs: [^ \ t \ r \ n \ f]
6	\w Correspond à un caractère de mot unique: [A-Za-z0-9_]
sept	\W Correspond à un caractère non-mot: [^ A-Za-z0-9_]

Cas de répétition

N ° Sr.	Exemple et description
1	ruby? Correspond à "rub" ou "ruby": le y est facultatif
2	ruby* Correspond à "frotter" plus 0 ou plus de y
3	ruby+ Correspond à "frotter" plus 1 ou plus de y
4	\d{3} Correspond exactement à 3 chiffres
5	\d{3,} Correspond à 3 chiffres ou plus
6.	\d{3,5} Correspond à 3, 4 ou 5 chiffres

Répétition sans réverbération

Cela correspond au plus petit nombre de répétitions -

N ° Sr.	Exemple et description
1	<.*> Répétition gourmande: correspond à "<python> perl>"
2	<.*?> Nongreedy: correspond à "<python>" dans "<python> perl>"

Regroupement avec des parenthèses

N ° Sr.	Exemple et description
1	\D\d+ Aucun groupe: + répète \ d
2	(\D\d)+ Groupé: + répète \ D \ d paire
3	([Pp]ython(, )?)+ Faites correspondre "Python", "Python, python, python", etc.

Références arrière

Cela correspond à nouveau à un groupe précédemment apparié -

N ° Sr.	Exemple et description
1	([Pp])ython&\1ails Compatible avec python et seaux ou Python et seaux
2	(['"])[^\1]*\1 Chaîne entre guillemets simples ou doubles. \ 1 correspond quel que soit le premier groupe correspondant. \ 2 correspond quel que soit le 2e groupe, etc.

Alternatives

N ° Sr.	Exemple et description
1	python|perl Correspond à "python" ou "perl"
2	rub(y|le)) Correspond à "rubis" ou "rouble"
3	Python(!+|\?) "Python" suivi d'un ou plusieurs! ou un ?

Ancres

Ce besoin de spécifier les positions de correspondance.

N ° Sr.	Exemple et description
1	^Python Correspond à "Python" au début d'une chaîne ou d'une ligne interne
2	Python$ Correspond à "Python" à la fin d'une chaîne ou d'une ligne
3	\APython Correspond à "Python" au début d'une chaîne
4	Python\Z Correspond à "Python" à la fin d'une chaîne
5	\bPython\b Correspond à "Python" à la limite d'un mot
6	\brub\B \ B n'est pas une limite de mot: correspond à "rub" dans "rube" et "ruby" mais pas seul
sept	Python(?=!) Correspond à "Python", s'il est suivi d'un point d'exclamation
8	Python(?!!) Correspond à "Python", s'il n'est pas suivi d'un point d'exclamation

Syntaxe spéciale avec parenthèses

N ° Sr.	Exemple et description
1	R(?#comment) Correspond à "R". Tout le reste est un commentaire
2	R(?i)uby Insensible à la casse lors de la correspondance "uby"
3	R(?i:uby) Comme ci-dessus
4	rub(?:y|le)) Grouper uniquement sans créer \ 1 backreference