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.