Dokuwiki

Ceci est une ancienne révision du document !

1. Généralités

Les expressions régulières représentent un langage à elles toute seule, embarqué dans des outils comme Java ou Perl, il s'agit d'un langage dans le langage ! Elles ont été conçues comme une généralisation du fameux “joker” (par exemple en SQL: LIKE 'a_virgin%'), afin de répondre à divers problèmes sur l'anlayse et le traitement des données textuelles: * trouver et compter des occurences de texte particulières * reconnaître ou valider une forme de texte particulière * remplacer des occurences de texte par une autre

Perl ayant été conçu originellement pour du “data mining”, il intègre de manière très symbiotique le mécanismes des expressions régulières. A tel point que Perl a défini un standard officieux pour les expressions régulières les plus ~~folles~~évoluées. En pratique, on distingue en général trois grandes familles d'expression régulières, qui ont toutes leur syntaxe propre même si elles partagent beaucoup d'éléments : * les expressions régulières POSIX (“Basique” dites'BRE', et “Etendues” dites 'Extended') * les expressions régulières Perl * les expressions régulières compatibles Perl ('PCRE')

Aujourd'hui la plupart des outils Unix traditionnels (sed, grep, awk, etc) supportent la version POSIX Etendue. L'exemple le plus classique de l'utilisation des PCRE est constitué par les fonctions preg_* de PHP.

2. Forme générale

Matching

En perl, une expression régulière est en général délimitée par le caractère '/'. L'opérateur qui permet d'évaluer une expression régulière sur une chaîne de caractère est '=~'. Par exemple : my $text = “Le chameau dans le desert”; print “Chameau en vue” if $text =~ /chameau/;

Cependant si l'on spécifie explicitement le préfixe 'm' (matching, implicite par défaut), on est alors libre de changer le délimiteur, ce qui peut être très pratique pour l'échappement : my $path = “/usr/bin/test”; print “un programme” if $path =~ m:/usr/bin/test:;

Par défaut, le résultat d'une opération de matching renvoie une valeur booléenne. Si on est à la recherche de plusieurs occurences et que l'on veut les compter, on utilise d'une part le suffixe 'g', et d'autre part on peut forcer l'évaluation en mode liste: Perl renvoie alors la liste des éléments de la chaîne qui matchent : my $text = “un chasseur sachant chasser”; my @cha = $text =~ /cha/g; print scalar(@cha).“ occurences”;

Enfin il est possible d'inverser le test : my $text = “Le chameau dans le desert”; print “Pas de chameau à l'horizon” if $text !~ /chameau/;

Substitution

L'écriture est très similaire, mais cette fois l'opération consiste à éventuellement modifier la chaîne traitée : my $text = “un chasseur sachant chasser”; $text =~ s/cha/cho/; # text devient 'un chosseur sachant chasser' $text =~ s/cha/cho/g; # text devient 'un chosseur sachont chosser'

On retrouve le même suffixe optionnel pour ne traiter que la première occurence (défaut) ou toutes les occurences (suffixe 'g').Une deuxième partie apparaît, qui spécifie le nouveau contenu lors des subtitutions: attention, cette deuxième partie 'n'est pas' une expression regulière.

Le résultat de l'opération est toujours le nombre de substitutions, quel que soit le contexte (liste ou scalaire) : my $text = “un chasseur sachant chasser”; print ($text =~ s/cha/cho/g).“ substitutions effectuéees”;

Extraction

Hormis le contexte liste du mode matching, il existe un moyen général pour récupérer des motifs reconnus par une expression régulière, il suffit d'utiliser les parenthèses : my @a = “Perl c'est bien” =~ /(.*) c'est (.*)/; # @a = (“Perl”, “bien”)

                                                 # $1 = "Perl"
                                                 # $2 = "bien"

La forme avec les variables '$1', '$2', etc. est la plus couramment utilisée.

3. Caractères spéciaux

Commençons par la liste des caractères spéciaux, c'est-à-dire qui on un sens particulier dans une expression regulière :