Dokuwiki

Outils pour utilisateurs

Outils du site

Piste :
perl:expressions_regulieres

Différences

Ci-dessous, les différences entre deux révisions de la page.

Lien vers cette vue comparative

Prochaine révision		Révision précédente
perl:expressions_regulieres [2009/03/15 01:02] – créée rootperl:expressions_regulieres [2013/03/13 11:09] (Version actuelle) – root
Ligne 1: Ligne 1:
-== 1. Généralités ==+====== 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: +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 +  * trouver et compter des occurences de texte particulières 
-* remplacer des occurences de texte par une autre+  * 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 : 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 POSIX ("Basique" dites**BRE**, et "Etendues" dites **Extended**) 
-* les expressions régulières Perl +  * les expressions régulières Perl 
-* les expressions régulières compatibles Perl ('''PCRE''')+  * 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.+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 ==+====== 2. Forme générale ======
  
-=== Matching ===+===== 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 : +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"; +<code perl> 
- print "Chameau en vue" if $text =~ /chameau/;+  my $text = "Le chameau dans le desert"; 
 +  print "Chameau en vue" if $text =~ /chameau/; 
 +</code>
  
-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 : +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"; +<code perl> 
- print "un programme" if $path =~ m:/usr/bin/test:;+  my $path = "/usr/bin/test"; 
 +  print "un programme" if $path =~ m:/usr/bin/test:; 
 +</code>
  
-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'' : +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"; +<code perl> 
- my @cha = $text =~ /cha/g; +  my $text = "un chasseur sachant chasser"; 
- print scalar(@cha)." occurences";+  my @cha = $text =~ /cha/g; 
 +  print scalar(@cha)." occurences"; 
 +</code>
  
 Enfin il est possible d'inverser le test : Enfin il est possible d'inverser le test :
- my $text = "Le chameau dans le desert"; +<code perl> 
- print "Pas de chameau à l'horizon" if $text !~ /chameau/;+  my $text = "Le chameau dans le desert"; 
 +  print "Pas de chameau à l'horizon" if $text !~ /chameau/; 
 +</code>
  
-=== Substitution ===+===== Substitution =====
  
 L'écriture est très similaire, mais cette fois l'opération consiste à éventuellement modifier la chaîne traitée : 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"; +<code perl> 
- $text =~ s/cha/cho/;  # text devient 'un chosseur sachant chasser' +  my $text = "un chasseur sachant chasser"; 
- $text =~ s/cha/cho/g; # text devient 'un chosseur sachont chosser'+  $text =~ s/cha/cho/; # text devient 'un chosseur sachant chasser' 
 +  $text =~ s/cha/cho/g; # text devient 'un chosseur sachont chosser' 
 +</code>
  
-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.+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) : 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"; +<code perl> 
- print ($text =~ s/cha/cho/g)." substitutions effectuéees";+  my $text = "un chasseur sachant chasser"; 
 +  print ($text =~ s/cha/cho/g)." substitutions effectuéees"; 
 +</code>
  
-=== Extraction ===+===== 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 : +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") +<code perl> 
-                                                   # $1 = "Perl" +  my @a = "Perl c'est bien" =~ /(.*) c'est (.*)/; # @a = ("Perl", "bien") 
-                                                   # $2 = "bien"+  # $1 = "Perl" 
 +  # $2 = "bien" 
 +</code>
  
-La forme avec les variables '''$1''', '''$2''', etc. est la plus couramment utilisée.+La forme avec les variables **$1**, **$2**, etc. est la plus couramment utilisée.
  
- +====== 3. Caractères spéciaux ======
-== 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 : Commençons par la liste des caractères spéciaux, c'est-à-dire qui on un sens particulier dans une expression regulière :
  
-{| bgcolor="#f7f8ff" cellpadding="3" cellspacing="0" border="1" style="font-size: 95%; border: gray solid 1px; border-collapse: collapse;" +^ **\** ^ Echappement du cacactère suivant^ 
-|- +| **^**, **$** | Début et fin de ligne| 
-|| '''\''' || Echappement du cacactère suivant +| **.** | Un caractère quelconque| 
-|- +| **|** | Alternative (ou logique)| 
-|| '''^''', '''$''' || Début et fin de ligne +| **()** | Groupement| 
-|- +| **[]** | Classes de caractère| 
-|| '''.''' || Un caractère quelconque +| ***** | 0, 1 ou plusieurs occurences| 
-|- +| **+** | 1 ou plusieurs occurences| 
-|| '''|''' || Alternative (ou logique) +| **?** | 0 ou 1 occurence| 
-|- +| **{}** | nombre variable d'occurences|
-|| '''()''' || Groupement +
-|- +
-|| '''[]''' || Classes de caractère +
-|- +
-|| '''*''' || 0, 1 ou plusieurs occurences +
-|- +
-|| '''+''' || 1 ou plusieurs occurences +
-|- +
-|| '''?''' || 0 ou 1 occurence +
-|- +
-|| '''{}''' || nombre variable d'occurences +
-|}+
  
-Tous les autres caractères sont considérés et recherchés tels quels dans les chaînes à traiter. Cela signifie qu'en particulier, si l'on veut pouvoir identifier la chaîne ''1+(2*3)=7'', il faudra '''échapper''' les caractères spéciaux : +Tous les autres caractères sont considérés et recherchés tels quels dans les chaînes à traiter. Cela signifie qu'en particulier, si l'on veut pouvoir identifier la chaîne //1+(2*3)=7//, il faudra **échapper** les caractères spéciaux : 
- /1\+\(2\*3\)=7/+  /1\+\(2\*3\)=7/
  
 Avec Perl, il est possible d'échapper de manière complète une séquence simplement en délimitant son début et sa fin : Avec Perl, il est possible d'échapper de manière complète une séquence simplement en délimitant son début et sa fin :
- /\Q1+(2*3)\E/+  /\Q1+(2*3)\E/
  
-== 4. Répétitions ==+====== 4. Répétitions ======
  
 Les motifs de recherche dans une expression de régulière peuvent être recherchés selon divers critères d'occurence : Les motifs de recherche dans une expression de régulière peuvent être recherchés selon divers critères d'occurence :
  
-{| bgcolor="#f7f8ff" cellpadding="3" cellspacing="0" border="1" style="font-size: 95%; border: gray solid 1px; border-collapse: collapse;" +^ (motif)* ^ Recherche zero, une ou plusieurs occurences de //motif//^ 
-|- +| (motif)+ | Recherche une ou plusieurs occurences de //motif//| 
-|| (motif)* || Recherche zero, une ou plusieurs occurences de ''motif'' +| (motif)? | Recherche zero ou une occurence de //motif//| 
-|- +| (motif){a} | Recherche exactement a occurences de //motif//| 
-|| (motif)+ || Recherche une ou plusieurs occurences de ''motif'' +| (motif){a,b} | Recherche entre a et b occurences de //motif//| 
-|- +| (motif){a,} | Recherche au moins a occurences de //motif//|
-|| (motif)? || Recherche zero ou une occurence de ''motif'' +
-|- +
-|| (motif){a}   || Recherche exactement a occurences de ''motif'' +
-|- +
-|| (motif){a,b} || Recherche entre a et b occurences de ''motif'' +
-|- +
-|| (motif){a,}  || Recherche au moins a occurences de ''motif'' +
-|}+
  
 Par défaut, l'opérateur de répétition ne s'adresse qu'au dernier caractère (ou classe de caractère, voir plus loin), on utilise donc les parenthèses (groupage) pour désigner un motif constitué de plusieurs caractères. Exemples : Par défaut, l'opérateur de répétition ne s'adresse qu'au dernier caractère (ou classe de caractère, voir plus loin), on utilise donc les parenthèses (groupage) pour désigner un motif constitué de plusieurs caractères. Exemples :
  
-{| bgcolor="#f7f8ff" cellpadding="3" cellspacing="0" border="1" style="font-size: 95%; border: gray solid 1px; border-collapse: collapse;" +^ /.*/ ^ Recherche une occurence quelconque, y compris la chaîne vide^ 
-|- +| /erreurs?/ | Recherche les occurence de "erreur" et "erreurs"| 
-|| /.*/ || Recherche une occurence quelconque, y compris la chaîne vide +| s/ +/ /g | Remplace toutes les suites d'espace par un seul espace|
-|- +
-|| /erreurs?/ || Recherche les occurence de "erreur" et "erreurs" +
-|- +
-|| s/ +/ /g || Remplace toutes les suites d'espace par un seul espace +
-|}+
  
-== 5. Classes de caractère ==+====== 5. Classes de caractère ======
  
 Si l'on veut rechercher un motif ne correspondant pas à une simple chaîne, mais un agencement quelconques de caractères prédéfinis, on peut utiliser les classes de caractère : Si l'on veut rechercher un motif ne correspondant pas à une simple chaîne, mais un agencement quelconques de caractères prédéfinis, on peut utiliser les classes de caractère :
  
-{| bgcolor="#f7f8ff" cellpadding="3" cellspacing="0" border="1" style="font-size: 95%; border: gray solid 1px; border-collapse: collapse;" +^ [A-Z] ^ Recherche n'importe quel caractère entre A et Z^ 
-|- +| [A-Za-z] | Recherche n'importe quel caractère entre A et Z ou a et z| 
-|| [A-Z] || Recherche n'importe quel caractère entre A et Z +| [!%%^%%0-9] | Recherche n'importe quel caractère qui n'est pas entre 0 et 9|
-|- +
-|| [A-Za-z] || Recherche n'importe quel caractère entre A et Z ou a et z +
-|- +
-|| [!^0-9] || Recherche n'importe quel caractère qui n'est pas entre 0 et 9 +
-|}+
  
 Exemples: Exemples:
  
-{| bgcolor="#f7f8ff" cellpadding="3" cellspacing="0" border="1" style="font-size: 95%; border: gray solid 1px; border-collapse: collapse;" +^ [A-Z]{2}-[0-9]{4} ^ Recherche un code de la forme XX-1234^
-|- +
-|| [A-Z]{2}-[0-9]{4} || Recherche un code de la forme XX-1234 +
-|}+
  
-Il existe des classes de caractères prédéfinies en Perl, elles permettent de gagner en concision. Chaque classe possède son complément (nom en majuscule décrivant une classe ne contenant '''pas''' les caractères désignés) :+Il existe des classes de caractères prédéfinies en Perl, elles permettent de gagner en concision. Chaque classe possède son complément (nom en majuscule décrivant une classe ne contenant **pas** les caractères désignés) :
  
-{| bgcolor="#f7f8ff" cellpadding="3" cellspacing="0" border="1" style="font-size: 95%; border: gray solid 1px; border-collapse: collapse;" +^ \w (\W) ^ Caractère de mot, cad. alphanumérique et "_"^ 
-|- +| \s (\S) | Espacement (espace, tabulation, retour chariot)| 
-|| \w (\W) || Caractère de mot, cad. alphanumérique et "_" +| \d (\D) | Numérique ([0-9])|
-|- +
-|| \s (\S) || Espacement (espace, tabulation, retour chariot) +
-|- +
-|| \d (\D) || Numérique ([0-9]) +
-|}+
  
-== 6. Ancres ==+====== 6. Ancres ======
  
 On peut également vérifier que le motif recherché est positionné à un endroit précis dans la chaîne de caractère, plus précisément au début où à la fin : On peut également vérifier que le motif recherché est positionné à un endroit précis dans la chaîne de caractère, plus précisément au début où à la fin :
  
-{| bgcolor="#f7f8ff" cellpadding="3" cellspacing="0" border="1" style="font-size: 95%; border: gray solid 1px; border-collapse: collapse;" +^ %%/^From (.*)/%% ^ Récupère dans $1 ce qui suit le "From " seulement si la ligne commence par "From "^ 
-|- +| %%s/!+$/./%% | Remplace une série de "!" en fin de ligne par un point| 
-|| /^From (.*)/ || Récupère dans $1 ce qui suit le "From " seulement si la ligne commence par "From " +| %%/^$/%% | Recherche les lignes vides|
-|- +
-|| s/!+$/./ || Remplace une série de "!" en fin de ligne par un point +
-|- +
-|| /^$/ || Recherche les lignes vides +
-|} +
  
-''A suivre...'' 
  
 +//A suivre...//
perl/expressions_regulieres.1237078928.txt.gz · Dernière modification : 2009/03/15 01:02 de root