Les modèles
La notion de modèle dans Perl est tout à fait comparable aux regexp Unix. Les modèles sont mis entre slashs :
$var =~ /abc/ ; |
# vrai si $var contient la chaine abc |
$var !~ /abc/ ; |
# vrai si $var ne contient pas abc |
/de+f/ |
# toute chaine contenant d, une ou plusieurs
répétitions de e, et f. |
/de*f/ |
# toute chaine contenant d, zéro ou plusieurs
répétitions de e, et f. |
/de?f/ |
# toute chaine contenant d, zéro ou une
occurence de e, et f. |
On utilise l'antislash comme caractère
d'échappement, par exemple si l'on veut que * ou ? soient
considérés comme des caractères
"normaux".
/de{3}f/ |
# toute chaine contenant d, 3 occurrences de e, et f. |
/de{1,3}f/ |
# toute chaine contenant d, 1, 2 ou 3 occurrences de e, et f. |
/de{2,}f/ |
# toute chaine contenant d, au moins 2 occurrences de e, et f. |
/d[eE]f/ |
# d, e ou E, f |
/d[^eE]f/ |
# d, n'importe quel caractère autre que e ou E, et f |
/[0123456]/ |
# un entier compris entre 0 et 6 |
/[0-6]/ |
# idem |
/^abc/ |
# chaîne commençant par abc |
/abc$/ |
# chaîne se terminant par abc |
/./ |
# n'importe quel caractère |
/def|ghi/ |
# toute chaîne contenant def ou ghi |
Ancres spéciales \b (extrémité) et \B (intérieur) :
/\bzz/ |
# concorde si zz est le début d'un mot |
/zz\b/ |
# concorde si zz est la fin d'un mot |
/\Bzz/ |
# concorde avec abzz mais pas avec zz |
/zz\B/ |
# concorde avec zzab |
/\Bzz\B/ |
# concorde avec abzzcd |
Caractères d'échappement
particuliers
/\d/ |
# n'importe quel chiffre |
/\D/ |
# n'importe quel caractère sauf un chiffre |
/\w/ |
# n'importe quelle lettre |
/\W/ |
# n'importe quel caractère sauf une lettre |
/\s/ |
# espace blanc |
/\S/ |
# n'importe quel caractère sauf un espace
blanc |
Réutilisation de portions de modèle
Il suffit de mettre cette portion entre
parenthèses, et on peut ensuite la
récupérer avec \n
,
où n
est l'entier
représentant la n-ième portion stockée
en mémoire.
La recherche d'une date au format jj-mm-aa peut par exemple correspondre au modèle
/\d{2}([\W])\d{2}\1\d{2}/
La mémoire de séquences de modèles n'est préservée que pour la longueur du modèle. Si l'on veut réutiliser une séquence dans un autre modèle, il faut définir une variable scalaire spéciale $n, où n est le numéro de la séquence dans le modèle auquel on fait référence. Les valeurs stockées dans $1, $2, ... sont effacées lorsqu'une nouvelle recherche de modèle est exécutée. Il faut donc les réaffecter si on veut les utiliser ultérieurement. La variable scalaire prédéfinie $& contient l'ensemble du modèle à rechercher.
Ordre de priorité des caractères spéciaux
( )
+ * ? { }
^ $ \b \B
|
Spécification d'un délimiteur de modèle au choix
Nous avons vu que le délimiteur de modèle par défaut est le slash (/). On peut utiliser le caractère que l'on souhaite à condition de préfixer le modèle par m :
m!abc! utilise le point d'exclamation comme délimiteur, par exemple.
Options de recherche de modèles
Les options se placent juste après le slash de fin de modèle. Les choix possibles sont :
g : recherche de tous les modèles possibles
i : ignorer la casse
m : traiter la chaîne comme des lignes multiples
s : traiter la chaîne comme une seule ligne
x : ignorer les espaces blancs
La recherche de tous les modèles possibles permet d'affecter les résultats d'une recherche à une liste et non à une simple variable. Ainsi,
@var = "taratata" =~ /.a/g
va affecter la liste ("ta","ra","ta","ta") à @var.
Opérateur de substitution
Il s'agit de la commande s/modèle_initial/modèle_de_remplacement/
qui fonctionne de la même manière que dans sed. Si
l'on veut supprimer un modèle, il suffit de le remplacer par
un modèle vide : s/modèle_initial//
Les options, qui se spécifient après le deuxième /, sont :
g : substituer toutes les occurrences du modèle
i : ignorer la casse
x : ignorer les espaces blancs (Perl 5)
e : traiter la chaîne de remplacement en tant qu'expression,
à évaluer avant la substitution
m : traiter la chaîne comme des lignes multiples
s : traiter la chaîne comme une seule ligne
La commande $chaine =~ s/[a-z]+/$& x 2/e permet par exemple de dupliquer une partie de la chaîne. En effet, si chaîne contient initialement "012ab34", le modèle correspond à "ab", qui est stocké dans la variable spéciale $&. Celle-ci est ensuite dupliquée par la commande x 2 ...
Supposons que l'on veuille multiplier tous les entiers d'un fichier par 2. Ce petit script fera l'affaire :
# !/usr/local/bin/perl
$count=0 ;
while ($ARGV[$count] ne "") {
open(FILE,"$ARGV[$count]") ;
@file = <FILE>
;
$linenum = 0 ;
while ($file[$linenum] ne
"") {
$file[$linenum] =~ s/\d+/$& * 2/eg;
$linenum ++;
}
close (FILE);
open (FILE,">
$ARGV[$count]") ;
print FILE (@file);
close (FILE);
$count++;
}
Ce programme tranfère le contenu de tous les fichiers passés en paramètres dans la liste @file, où est effectuée la susbstitution, avant d'écraser le contenu du fichier initial.
On peut également spécifier un délimiteur de modèles différent du slash standard, surtout pour éviter les confusions. Ainsi,
s#/u/bin/#/usr/bin/#
permet de ne pas mélanger les / de séparation de modèle et ceux d'indication d'arborescence.
Opérateur de transcription
L'opérateur tr marche comme la commande Unix du même nom. Elle permet de remplacer une chaîne par une autre, caractère par caractère.
L'option c permet de transcrire le complément de ce
qui est spécifié, alors que l'option d permet de
supprimer les caractères spécifiés.
L'option s, quant à elle, permet de remplacer les
caractères multiples à résultat
identique par un seul caractère. Ainsi, $chaine
=~ tr/\d/ /c
remplace tous les caractères
à l'exception des chiffres par un espace, et $chaine =~
tr/\t /d; supprime toutes les tabulations et tous les espaces.
Fonctions étendues de recherche de modèle
- On peut mettre un modèle entre parenthèses sans l'enregistrer, en le faisant précéder, dans la parenthèse, par ?:
- Conditions préalables ; le modèle /abc(?=def)/
concorde avec abc
uniquement s'il est suivi
de def
. De même, /abc(?!def)/
concorde avec abc
uniquement si abc
n'est pas suivi par def
.