Les expressions rationnelles en PERL

Introduction

Le livre de référence utilisé : Introduction à PERL (O'Reilly)
Pour aborder les expressions rationnelles, voir cette introduction
Les expressions rationnelles (ou régulières) sont des critères ou modèles de recherche (pattern) dans les chaines de caractères. Les chaines trouvées sont ensuite soumises à un traitement, en shell par des utilitaires comme grep, sed, awk, ou dans un langage de script comme Perl ...
Attention !
Certains caractères spéciaux sont communs avec les caractères génériques de désignation de fichiers (comme * ? ), mais ils ont une interprétation différente. Donc il faut toujours prêter attention au contexte

Quelques exemples élémentaires

Une expression rationnelle est une chaine encadrée (en PERL) par /../, appelé opérateur de correspondance, qui applique le modèle par défaut sur la variable $_, et renvoie vrai ou faux.
Par exemple, sur la ligne courante d'un fichier, contenue dans $_, recherche de la séquence az :
```
if (/az/) { 
print $_ ; 
}
```
Pour appliquer le modèle à une autre variable, il faut utiliser l'opérateur =~ comme dans l'exemple :
```
if ($var =~ /az/) {
print $var ; 
}
```

Exemple : script cherche-az, pour rechercher la séquence "az":

# pour opérer sur toutes les lignes saisies au clavier ou récupérées sur l'entrée standard
# rappel : chaque ligne de l'entrée est stockée dans l'argumement par défaut $_
# appel : cat fichier |cherche-az
while () {
if (/az/) { print $_ ; }
}  
# pour opérer sur toutes les lignes d'un fichier 
# appel cherche-az
open(IN, "~/essai.txt"); 
while () {
 chomp($_);
 if (/az/) { print "$_ \n"; }
}

L'opérateur de correspondance

L'opérateur /.../ et ses options

Il s'agit de tester la présence dans une chaîne de caractères d'un motif particulier, et d'en trouver toutes les occurrences. Pour cela on applique une expression régulière, soit expreg permettant de reconnaitre le motif. En Perl, cette fonction sera alors notée symboliquement /expreg/.
On peut utiliser une autre syntaxe m_expreg_ où les 2 caractères _ doivent être remplacés par un même symbole délimitateur, par exemple :
```
if ($var =~ m%expreg%) {
print $var
}
```
Ce symbole m dans l'expression m/regexp/ est habituellement omis si le délimiteur de l'expression est un slash /.
Dans ce cas, si un / est présent dans l'expression, il faut le "protéger" par \/

Le motif /expreg/ peut être suivi de paramètres dont voici le rôle :

g la recherche est globale, de toutes les occurences
i ne pas distinguer minuscules et majuscules

s traiter la chaîne comme une ligne simple (défaut)

m traiter la chaîne comme une ligne multiple

o ne compiler l'expression qu'une seule fois

x utiliser les expressions régulières étendues

Interpolation de variables

Perl commence l'analyse de l'expression rationnelle en remplaçant les noms de variables par leur valeur

# recherche de "info" en début du texte
$mot="info";
$texte=<STDIN>; chomp($texte);
if ($texte =~ /^$mot/) { ...

Exemples

Pour comparer le début de la saisie à la chaine oui, quelle que soit la casse
```
if ( =~ /^oui/i) { ...
```

Pour controler la présence d'un mot dans une chaine

$inf="informatique";
$opt="option";
$chaine="Toujours pas d'informatique enseigné comme option des lycées en l'an 2000 ...";
if (($chaine =~ /\b$inf\b/i) && ($chaine =~ /\b$opt\b/i)) {
 print "on parle enfin de l'option info !";
 }

Valeurs de retour

La valeur retournée par la fonction dépend du contexte dans lequel elle est appelée.
Dans un contexte scalaire, la fonction renvoie une valeur non nulle en cas de succès, et sinon la valeur undefined $code = ($chaine =~ /expreg/);

Dans un contexte de liste, la fonction renvoie la liste des éléments qui ont vérifié les expressions entre parenthèses. Si l'expression ne correspondait pas, on obtient une liste nulle.

($href) = ($chaine =~ //i);

Dans tous les cas, la fonction fixera les variables 2, ... avec les éléments qui ont reconnu les expressions entre parenthèses.

Fonctions s,split et join

split décompose une chaine en parties toutes séparées par un motif reconnu et construit une liste composée de ces éléments Exemples

# @mots va contenir la liste des mots de la phrase, séparés par un ou plusieurs espaces
$texte="Quel dommage que l'option informatique ait été supprimée !";
@mots= split(/ +/, $texte);

# dans la boucle, @liste va contenir la liste de tous les champs (même le second qui est vide)
# une ligne étant de la forme jean:x:500:500::/home/jean:/bin/bash
$fichier="/etc/passwd";
open(F, $fichier);
while (<F>) {
@liste = split(/:/);
....
}
une meilleure solution pour un traitement sur les valeurs de la liste :
$fichier="/etc/passwd";
open(F, $fichier);
while ($user = <F>) {
($nom, $mdp, $uid, $gid, $titre, $home, $shell) = split(/:/, $user);
....
}

Exercices

A suivre ...

g	la recherche est globale, de toutes les occurences
i	ne pas distinguer minuscules et majuscules
s	traiter la chaîne comme une ligne simple (défaut)
m	traiter la chaîne comme une ligne multiple
o	ne compiler l'expression qu'une seule fois
x	utiliser les expressions régulières étendues