FAQ PerlConsultez toutes les FAQ

Nombre d'auteurs : 18, nombre de questions : 250, dernière mise à jour : 29 octobre 2015  Ajouter une question

 

Bienvenue sur la FAQ Perl. Cette FAQ a pour vocation de vous enseigner ou de vous faire revoir les notions élémentaires de ce fantastique langage. Perl est très utilisé dans différents domaines depuis la gestion système, le réseaux, l'administration de bases de données, le web (CGI), la bureautique, la conception d'interfaces graphiques ou des contextes scientifiques telle la bioinformatique. Nous espérons que cette FAQ vous sera d'une grande utilité.

Vous souhaitez participer à l'amélioration de cette FAQ, n'hésitez pas !! Commentez

Bonne lecture !


SommaireS'initier à PerlExpressions régulièresClasses de caractères (8)
précédent sommaire suivant
 

  • tout caractère alphabétique en minuscule: [a-z] ;
  • tout caractère alphabétique en majuscule : [A-Z] (il existe des options pour prendre en compte la casse, voir plus loin) ;
  • tout caractère numérique : [0-9] ;
  • tout caractère alphanumérique : [a-zA-Z0-9].

Mis à jour le 8 mai 2005 djibril

Notation Signification Equivalent
\n Un retour chariot.
\t Une tabulation.
^ Le caractère spécial "^" a deux significations différentes :
Dans un ensemble [..], il signifie "tout sauf"
En dehors il signifie "ligne commence par"
[^0-9]
/^dji/
\w Un caractère alphanumérique, avec le "souligné" couramment appelé "underscore" ( _ ). [a-zA-Z0-9_]
\W Tout sauf un caractère alphanumérique et le souligné ( _ ) compris. [^a-zA-Z0-9_]
\d un caractère numérique. [0-9]
\D Tout sauf un caractère numérique. [^0-9]
\s Un espace.
\S Tout sauf un espace.
$ Fin de ligne. /son$/ expression se terminant par "son"
$& Motif qui correspond à l'expression régulière. /motif/ (exemple ci-dessous)
$` Sous-ensemble qui se trouve avant $&. (exemple ci-dessous)
$' Sous-ensemble qui se trouve après $&. (exemple ci-dessous)
Voici un exemple de script utilisant différents caractères :

Code perl : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#!/usr/bin/perl 
use warnings; 
use strict; 
use Carp; 
my $mon_texte = "Il fera beau d'ici 15 heures 30"; 
if ( $mon_texte =~ /fera/ ) { 
    print "$&\n"; 	# $& = "fera" 
    print "$`\n";	# $` = "Il ", attention, l'espace est aussi récupéré 
    print "$'\n";       # $' = " beau d'ici 15 heures 30" 
} 
if ( $mon_texte =~ /\d$/ ) { 
    print "$mon_texte\n"; 	# Il fera beau d'ici 15 heures 30 
} 
if ( $mon_texte =~ /[0-9]$/ ) {	# Ecriture semblable à la précédente 
    print "$mon_texte\n"; 	# Il fera beau d'ici 15 heures 30 
} 
if ( $mon_texte =~ /[a-z]$/ ) { 
    print "OK\n"; 	 
} 
else { 
    print "Pas de bol\n";	# Pas de bol (car ma chaîne ne se termine pas par un caractère alphabétique)	 
}

Mis à jour le 8 mai 2005 djibril

Il s'agit maintenant d'étudier "le langage" des expressions régulières, fondé sur le rôle d'opérateur des métacaractères. Rappelons qu'il faut les "échapper" avec "\" pour neutraliser leur action d'opérateurs.

Notation Signification
. Représente un caractère quelconque, sauf \n (comportement par défaut, modifiable).
* Marque la possible répétition du caractère précédent (ou de l'expression précédente entre parenthèses) 0 ou n fois.
+ Marque la répétition du caractère précédent (ou de l'expression précédente entre parenthèses) au MOINS 1 fois.
? Marque la possible répétition du caractère précédent (ou de l'expression précédente entre parenthèses) 0 ou 1 fois.
[..] Recherche L'UN des caractères de l'ensemble des caractères entre crochets.
[^..] Recherche tout sauf les caractères qui sont entre les crochets.
^ La recherche s'effectue en début de chaîne ex : /^regex/.
$ La recherche s'effectue en fin de chaîne ex : /regex$/.
\ Annule le rôle de métacaractère du caractère qui suit, et lui permet d'avoir sa signification usuelle.
| Joue le rôle de "ou" entre 2 expressions. (ex : /toto|titi/) => toto ou titi.
(...) Rôle de groupement et de mémorisation de la regex comprise.
{n,m} Le nombre de répétitions attendu va de n à m (et porte sur le caractère ou l'expression précédent), m et n inférieurs à 65536.
{n} Le nombre de répétitions attendu doit être exactement égal à n.
{n,} Le nombre de répétitions attendu est au moins n.
{,m} Le nombre de répétitions attendu est au plus m.
{0,} {1,} {0,1} équivalent respectivement à *, + et ?
N.B. : les Métacaractères sont : " ^ | { } [ ] ( ) / \ $ + * ? ." Exemple sur l'utilisation du "\":

Code perl : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
#!/usr/bin/perl 
use warnings; 
use strict; 
use Carp; 
my $chaine = "La/les maison(s) en Normandie "; 
  
# Pour empêcher que Perl interprète "/ ( )" dans ma chaîne comme des métacaractères, 
# on utilise le "\" 
if ( $chaine =~ /^La\/les maison\(s\)/ ) { 
  print " La ligne est $chaine ";    # => La/les maison(s) de Normandie 
}
Il existe une méthode beaucoup plus propre et lisible pour la manipulation des métacaractères. Elle consiste à utiliser la fonction Perl quotemeta() qui protège tous les métacaractères d'une chaîne. Exemple :

Code perl : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
#!/usr/bin/perl 
use warnings; 
use strict; 
  
my $chaine  = "La/les maison(s) en Normandie coûte 200 000 euros"; 
my $pattern = "La/les maison(s)"; 
$pattern = quotemeta($pattern); 
  
if ( $chaine =~ /^$pattern/ ) { 
  print " la ligne est $chaine "; 
}
Code : Sélectionner tout
1
2
mon pattern : La\/les\ maison\(s\) 
 la ligne est La/les maison(s) en Normandie coûte 200 000 euros

Mis à jour le 8 mai 2005 djibril

Ce sont des symboles dont la présence indique une contrainte de positionnement du motif à la recherche dans le texte. Nous les avons déjà étudiés ci-dessus.

^pipo La recherche du motif pipo doit être effectuée uniquement en début de chaîne.
   regex$    recherche du motif regex doit être effectuée uniquement en fin de chaîne.

Mis à jour le 8 mai 2005 djibril

La présence de parenthèses autour d'une partie d'un motif (qu'on appellera sous-motif) est nécessaire pour plusieurs raisons et objectifs : Exemple :

  • pour marquer un regroupement de plusieurs caractères sur lesquels on veut agir, le plus souvent, par la pose d'un quantificateur. Pensez à la différence entre les "mots" papa+ et pa(pa)+ ;
  • pour signifier le besoin de mémoriser la sous-chaîne du texte étudié qui satisfait le sous-motif. On parle pour cette raison de parenthèses de capture. On peut référencer le sous-motif par $1 à $n ($n est une variable spéciale : le contenu de la n-ième parenthèse).

Code perl : Sélectionner tout
1
2
3
4
5
6
7
8
9
#!/usr/bin/perl 
use warnings; 
use strict; 
  
my $chaine = "les maisons valent 5000000 euros"; 
if ( $chaine =~ /\s(\d+\seuros)$/ ) { 
  my $prix = $1; 
  print "il coute donc $prix\n";    #il coute donc 5000000 euros 
}
Une autre façon :

Code perl : Sélectionner tout
1
2
3
4
5
6
7
8
9
#!/usr/bin/perl 
use warnings; 
use strict; 
  
my $chaine = "les maisons valent 5000000 euros"; 
my ($prix, $monnaie) = $chaine =~ /\s(\d+)\s+(euros)$/; 
if ( defined $prix ) { 
  print "Il coute donc $prix $monnaie\n";    # Il coute donc 5000000 euros 
}
Dans le deuxième exemple ci-dessus, il est important de ne pas oublier les parenthèses "($prix,$monnaie)" car les motifs $1, $2... $n sont renvoyés sous forme de liste.

Il existe une autre façon de capturer depuis perl 5.10 : captures nommées. Voici un exemple :

Code perl : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
#!/usr/bin/perl 
use warnings; 
use strict; 
  
my $chaine = "les maisons valent 5000000 euros"; 
if ( $chaine =~ /\s(?<prix>\d+)\s+(?<monnaie>euros)$/ ) { 
  print "Il coute donc $+{prix} $+{monnaie}\n";    # Il coute donc 5000000 euros 
} 
  
foreach my $nom_capture ( keys %+ ) { 
  print "$nom_capture : ", $+{$nom_capture},"\n"; 
}
Code : Sélectionner tout
1
2
3
Il coute donc 5000000 euros 
monnaie : euros 
prix : 5000000
C'est assez pratique. Les captures se retrouvent dans la table de hachage spéciale %+.

Mis à jour le 8 mai 2005 djibril

Une expression régulière peut être suivie d'options cumulables, que l'on appelle modificateurs. Ils modifient l'interprétation d'une expression régulière.

Code perl : Sélectionner tout
1
2
3
if ( $toto =~ /expr/msogix ) {  
  # ... 
}
Notation Signification
i Recherche insensible à la casse (majuscules/minuscules).
g La recherche est globale, de toutes les occurrences.
x Les espaces et sauts de lignes sont ignorés. le caractère #
permet de faire un commentaire (pensez à l'utiliser avec les séparateurs {}{}.
m Traiter la chaîne comme des lignes multiples (^ et $ s'appliqueront à chaque ligne).
s Traiter la chaîne comme une ligne simple (le caractère . reconnaît aussi les sauts de ligne).
o Compilation du motif uniquement la première fois.

Exemple de script utilisant ces modificateurs :

Code perl : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#!/usr/bin/perl 
use warnings; 
use strict; 
  
my $chaine = "atgccATCccca"; 
if ( $chaine =~ /[atgcATGC]/ ) { 
  print "OK sans utiliser l'option i\n";    #=> OK sans utiliser l'option i 
} 
if ( $chaine =~ m/[atgc]/i ) { 
  print "OK avec utiliser l'option i\n";    #=> OK avec utiliser l'option i 
} 
if ( $chaine =~ /(atc)/gi ) { 
  print "motif $1 trouvé\n";               #=> motif ATC trouvé 
} 
  
my $mon_texte = "il fait jour\nIl fait nuit\nBonsoir"; 
if ( $mon_texte =~ /jour$/ ) { 
  print "$mon_texte\n";                     #=> rien 
} 
if ( $mon_texte =~ /jour$/m ) { 
  print "$mon_texte\n";                     #=> il fait jour 
  
  #   Il fait nuit 
  #   Bonsoir 
}
Voici un exemple d'utilisation des modificateurs msx (utilisation récommandée), ainsi que l'utilisation des séparateurs {}

Code perl : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#!/usr/bin/perl 
use warnings; 
use strict; 
  
my $chaine = "les maisons valent 5000000 euros\nl'hôtel coute 100000 dollars\n"; 
my (?ta) = $chaine =~ m{       # m => signifie match 
                        ^[^\n]+  # ligne commence par tout sauf un \n jusqu'à l'espace   
                         \s      # Reconnait un espace 
                         (\d+)   # capture un nombre 
                         \s*     # suivi de plusieurs espaces ou non 
                         (\w+)   # suivi d'un mot capturé 
                         $       # Fin d'une ligne 
                          }gmxs;    # m => multiligne 
                                    # x permet d'ignorer les blancs et les \n et 
                                    # les commentaires via # 
                                    # s => le point reconnait maintenant le \n 
                                    # g => plusieurs occurrences 
if (?ta) { 
  foreach ( keys ?ta ) { 
    print "$_ : $data{$_}\n"; 
  } 
}

Mis à jour le 8 mai 2005 djibril

Comme le fait la commande "sed" sous Unix, Perl permet de faire des remplacements sur une chaîne de caractères en utilisant

Code perl : Sélectionner tout
$chaine =~ s/motif/remplacement/;
Code perl : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#!/usr/bin/perl 
use warnings; 
use strict; 
my @fruits = qw (banane pomme melon); 
  
foreach (@fruits) { 
  s/e$/es/; 
} 
print "@fruits\n";    #bananes pommes melon 
  
my $tel = "01.12.22.44.99"; 
$tel =~ s{ 
         0         # le 0 sera remplacé 
         ([^\n]+)  # numero à capturer 
          } 
         {\+(00\.33) $1}xms; 
print "$tel\n";       #+(00.33) 1.12.22.44.99 
my $arbres = "manguier pommier cerisier"; 
$arbres =~ s/(\w+)ier/arbres à $1es,/g; 
print "list: $arbres\n";    #=> list: arbres à mangues, arbres à pommes, arbres à cerises, 
$arbres =~ s/,$/./; 
print "list: $arbres\n";    #=> list: arbres à mangues, arbres à pommes, arbres à cerises.
tr Cette commande permet de transformer une chaîne en une autre chaîne ou de modifier des occurrences dans une chaîne.
split Découpe et range dans une liste les éléments trouvés contenus entre un délimiteur défini. split(délimiteur,$variable, $option);, $option est facultatif.
      join       Concatène une valeur à chaque élément d'une liste et range le tout dans une variable. join($valeur,@list);
Code perl : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
# tr 
$name =~ tr/A-Z/a-z/;    # Transforme toutes les majuscules en minuscules 
$name =~ tr/er/ab/;      # Transforme les e en a et les r en b 
  
# split 
$a = "1:2:3:4::5"; 
@list = split( /:/, $a );    #=> ("1","2","3","4","","5") 
  
# join 
$valeur = "+"; 
@list   = ( "1", "2", "3", "4" ); 
$res    = join( $valeur, @list );    #=> ("1+2+3+4+")

Mis à jour le 8 mai 2005 djibril

Le motif recherché peut être une lettre, un chiffre, ou tout simplement une expression (un nombre, un bout de phrase, etc). Il existe différentes façons d'écrire une expression régulière.

Mis à jour le 8 mai 2005 djibril

Proposer une nouvelle réponse sur la FAQ

Ce n'est pas l'endroit pour poser des questions, allez plutôt sur le forum de la rubrique pour ça


Réponse à la question

Liens sous la question
précédent sommaire suivant
 

Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright © 2017 Developpez Developpez LLC. Tous droits réservés Developpez LLC. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents et images sans l'autorisation expresse de Developpez LLC. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.

 
Responsable bénévole de la rubrique Perl : djibril -