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

Les deux révisions précédentesRévision précédente
perl:expressions_regulieres [2009/03/15 01:11] – rootperl:expressions_regulieres [2013/03/13 11:09] (Version actuelle) – root
Ligne 19: Ligne 19:
  
 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 :
 +<code perl>
   my $text = "Le chameau dans le desert";   my $text = "Le chameau dans le desert";
   print "Chameau en vue" if $text =~ /chameau/;   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 :
 +<code perl>
   my $path = "/usr/bin/test";   my $path = "/usr/bin/test";
   print "un programme" if $path =~ m:/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// :
 +<code perl>
   my $text = "un chasseur sachant chasser";   my $text = "un chasseur sachant chasser";
   my @cha = $text =~ /cha/g;   my @cha = $text =~ /cha/g;
   print scalar(@cha)." occurences";   print scalar(@cha)." occurences";
 +</code>
  
 Enfin il est possible d'inverser le test : Enfin il est possible d'inverser le test :
 +<code perl>
   my $text = "Le chameau dans le desert";   my $text = "Le chameau dans le desert";
   print "Pas de chameau à l'horizon" if $text !~ /chameau/;   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 :
 +<code perl>
   my $text = "un chasseur sachant chasser";   my $text = "un chasseur sachant chasser";
   $text =~ s/cha/cho/; # text devient 'un chosseur sachant chasser'   $text =~ s/cha/cho/; # text devient 'un chosseur sachant chasser'
   $text =~ s/cha/cho/g; # text devient 'un chosseur sachont chosser'   $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) :
 +<code perl>
   my $text = "un chasseur sachant chasser";   my $text = "un chasseur sachant chasser";
   print ($text =~ s/cha/cho/g)." substitutions effectuéees";   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 :
 +<code perl>
   my @a = "Perl c'est bien" =~ /(.*) c'est (.*)/; # @a = ("Perl", "bien")   my @a = "Perl c'est bien" =~ /(.*) c'est (.*)/; # @a = ("Perl", "bien")
   # $1 = "Perl"   # $1 = "Perl"
   # $2 = "bien"   # $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 ======
Ligne 131: Ligne 137:
  
 //A suivre...// //A suivre...//
- 
perl/expressions_regulieres.1237079515.txt.gz · Dernière modification : 2009/03/15 01:11 de root