Cours n° 8, 21 novembre 2013

Jean-François Perrot

Expressions régulières en Perl - 1

1. Contextes de mise en œuvre des expressions régulières
   1. Généralité
   2. Variété
   
   
2. Utilisation des e.r. en Perl
   1. Les e.r. apparaissent en Perl dans trois contextes
   2. Le caractère séparateur
   
   
3. Exemples
   1. Couper sur les blancs et les tabulations
   2. Les nombres (v.1)
   3. Les commentaires à la C (v. 1)
   4. Ajoutons-y les commentaires en fin de ligne

Contextes de mise en œuvre des expressions régulières

1. Généralité

   Les e.r. sont utilisées à peu près dans toutes les situations où interviennent des textes, à commencer par la programmation en shell.
   Pendant longtemps, malheureusement, dans chacune de ces situations, la syntaxe utilisée pour les e.r. variait légèrement, mais suffisamment pour faire de leur utilisation un redoutable casse-tête.
   La situation s'est améliorée aujourd'hui, la syntaxe proposée par Perl étant assez généralement adoptée.
   
   En shell : grep et sed
grep expreg fichier -> imprime les lignes du fichier qui contiennent expreg
sed expreg edition fichier -> effectue la commande edition sur les lignes du fichier qui contiennent expreg
   

2. Variété

   Suivant les langages de programmation, les e.r. peuvent prendre des statuts différents :
   
   • en Java et en JavaScript ce sont des objets d'un type particulier,
   • en Perl et en PHP ce sont des êtres bizarres qui sont donnés par des chaînes de caractères
     - mais qui n'en sont certes pas ! 
     
   Cette interrogation sur l'essence des e.r. dans un langage donné est en fait d'un intérêt secondaire.
   L'essentiel est de connaître le contexte dans lequel elles apparaissent, c'est-à-dire leur mode d'emploi.
   
   Or, même si tous les langages proposent grosso modo les mêmes fonctionnalités,
   les détails de syntaxe pour obtenir ces fonctionnalités varient fortement.
   On n'utilise pas les e.r. (même si elles s'écrivent grosso modo de façon identique) par les mêmes procédés
   
   • en PHP (où il existe une batterie de fonctions spécialisées)
   • en JavaScript (où on doit distinguer selon que l'on parle à une chaîne ou à un objet RegExp.)
   • en Java (où on distingue soigneusement les objets de type String, Pattern et Matcher)
   • et en Perl !
   Nous nous limiterons ici au cas de Perl.
   

Utilisation des e.r. en Perl

• Les e.r. apparaissent en Perl dans trois contextes :

  1. comme argument d'une fonction comme split ou grep (1er arg. ) :
     
     split(/b/, 'aaabccbacbc') -> ('aaa', 'cc', 'ac', 'c')
     (coupe la chaîne en tranches séparées par les sous-chaînes maximales filtrées par l'e.r. passée en 1er arg,
     renvoie la liste des tranches).
     Essai minimal à faire fonctionner et à modifier...
     
     grep(/a/, ('aaa', 'cc', 'ac', 'c')) -> ('aaa','ac')
(renvoie la sous-liste formée de toutes les chaînes contenant une sous-chaîne filtrée par l'e.r. passée en 1er arg.)
     Essai minimal à faire fonctionner et à modifier...
     
     
  2. en position de filtre (avec m comme match) par rapport à une chaîne, engendrant une valeur booléenne :
     "abc" =~ m/b/  -> true mais "abc" =~ m/d/  -> false
     et nous verrons aussi un autre usage de cette construction, "en contexte de liste".
     Essai minimal à faire fonctionner et à modifier...
     
     
  3. en position de substitution (avec s comme substitute) par rapport à une variable (ou plus généralement par rapport à une L-value),
     avec modification de la valeur de cette variable (affectation) :
     my $x = "abc"; $x =~ s/b/pp/; ==> la variable $x vaut "appc".
Essai minimal à faire fonctionner et à modifier...
     
     

• Le caractère séparateur

  L'emploi en filtre et en substitution fait voir le rôle du caractère séparateur '/' qui encadre l'e.r. dans le filtre m/e.r./ 
  et délimite la chaîne à substituer dans s/e.r./subst/.
  Ce caractère séparateur est arbitraire : son choix est affaire de commodité,
  sachant que s'il doit apparaître dans le corps de l'e.r. il faudra le "déspécifier" par un anti-slash.
  
  La barre oblique '/' est utilisable dans tous les cas,
  tandis qu'après l'indicateur de fitrage m ou de substitution s, on peut choisir un séparateur quelconque.
  Exemple.
  
  Cet indicateur étant absent lorsqu'on passe une e.r. comme argument d'une fonction,
  seul le séparateur '/' est accepté dans ce cas.
  foreach my $s ( split( %/%, ' un jour / mon prince / viendra' )){
    print "$s\n";
}
  provoque une erreur de syntaxe - alors que
  my $ch = ' un jour / mon prince / viendra';
$ch =~ s%/%€%;
  donne comme attendu un jour € mon prince / viendra.
  Il faut écrire split( /\//, ' un jour / mon prince / viendra' )
  ou plus simplement, en exploitant qu'une simple chaîne peut tenir lieu d'e.r.
  split( '/', ' un jour / mon prince / viendra' )
  
  Une e.r. en Perl est donc donnée par une chaîne de caractères encadrée par un caractère séparateur  '/'.
  Attention ! elle est donnée par une chaîne entre '/', elle n'est pas cette chaîne entre '/'...
  On ne peut pas écrire : "my $er = /a/;", par exemple, mais bien "my $er = 'a'; grep(/$er/....) ".
  
  Cette chaîne doit être conforme à la syntaxe des e.r. en Perl, que nous allons explorer dans la suite.
  Tout ce que nous avons vu de l'extension LEX avec le logiciel automate reste valable.
  

Exemples

1. Couper sur les blancs et les tabulations

   pour interpréter un texte sur deux colonnes comme un tableau associatif (hash) :
   

   Luc         12 Maurice     18 Juliette    07

   <----------->

   my %tab; $tab{'Luc'} = 12 $tab{'Maurice'} = 18 $tab{'Juliette'} = 07

   
   

   ---

   open(ENTREE, "<$fich");

my %tab;
my @tablignes = <ENTREE>;
foreach my $ligne ( @tablignes ){
    chomp($ligne); # supprime le "\n" final
    my ($le_nom, $la_note) = split( /[ \t]+/, $ligne);
    $tab{$le_nom} = $la_note;
}
return %tab;

   ---

   
   fichier TxtVersTab.pl, avec un fichier-exemple pour essais NomsNotes.txt.
   
   Fonctionnement (en ligne de commande) :
   jfp% perl TxtVersTab.pl NomsNotes.txt
Elsa09Franck12Maurice18Kevin09Elisabeth07Joseph09Josette19Max07Aline12Antoinette12Julien13Alexandre09Ernestine18Mauricette12Jules11Francine13Pierre08Hélène13Jean-Pierre09Juliette07Christine12Paulette09Jacques09Luc12
   
   Cette sortie est obtenue en demandant "print %tab", elle donne les noms-notes dans un ordre arbitraire, rassemblés en une seule chaîne.
   Voici une version plus perfectionnée, avec une impression dans le même ordre, mais ligne à ligne : fichier TxtVersTabP.pl.

2. Les nombres (v.1)

   Avec l'expression censée représenter les nombres écrits en décimal, en octal et en hexadécimal (sur son élaboration, voyez ici):
   [1-9][0-9]*|0([0-7]+|x[0-9A-F]+)
   extraire d'un texte toutes les sous-chaînes maximales représentant des nombres ? Pas tout de suite...
   Commençons par extraire toutes les lignes contenant des nombres :
   
   

   ---

   sub extrnb1($){ #arg. nom de fichier
    my ($fich) = @_;
    open(ENTREE, "<$fich");

    my $er = '[1-9][0-9]*|0([0-7]+|x[0-9A-F]+)';
    my @tablignes = <ENTREE>;
    my @tabnb = grep(/$er/, @tablignes);
    foreach my $lgn ( @tabnb ){
       print $lgn; #le saut de ligne est resté en place !
    }
}#extrnb

   ---

   
   fichier extrnb1.pl, donnée pour essais nb.txt.
   
   Variante : trouver dans un texte HTML ou XML les lignes contenant des entités-caractères, comme ø ou 𠊚
   désignant des caractères Unicode par leur numéro en décimal ou en hexadécimal.
   my $er = '&#([1-9][0-9]*|x[0-9A-F]+);';
   etc.
   

3. Les commentaires à la C (v. 1)

   que nous avons déjà vus : /[*]([^/*]|[/]|[*]+[^/*])*[*]+/
   
   Renvoyer un texte en supprimant tous les commentaires... ???
   commençons par supprimer le premier !
   

   ---

   sub supprCommC($){ #arg. nom de fichier
    my ($fich) = @_;
    open(ENTREE, "<$fich");

    my $erc = '/[*]([^/*]|[/]|[*]+[^/*])*[*]+/'; #sans '\'
    my @tablignes = <ENTREE>;
    my $txt = join('', @tablignes); # regroupe toutes les lignes en une seule chaîne
    $txt =~ s=$erc= =; # avec '=' comme séparateur pour ne pas avoir à marquer les '/' par '\'
    print $txt;

}#supprCommC
   

   ---

   
   fichier supprCommC.pl, donnée pour essais exCom.txt.
   Regardez bien le résultat...
   
   Si vous voulez supprimer tous les commentaires, il faut ajouter le suffixe g (comme global) à la fin de la substitution :
   $txt =~ s=$erc= =g;
   

4. Ajoutons-y les commentaires en fin de ligne

   que nous avons aussi vus : //[^\n]*\n
   même question...
   

   ---

   sub supprToutComm($){ #arg. nom de fichier
    my ($fich) = @_;
    open(ENTREE, "<$fich");

    my $erc = '/[*]([^/*]|[/]|[*]+[^/*])*[*]+/'; # la même
    my $erfl = '//[^\n]*\n'; # idem
    my $er = "$erc|$erfl"; # disjonction ou réunion...

    my @tablignes = <ENTREE>;
    my $txt = join('', @tablignes);
    $txt =~ s=$er= =; # avec '=' comme séparateur
    print $txt;
}#supprToutComm
   

   ---

   
   fichier supprCommCFL.pl, donnée supplémentaire pour essais exCom2.txt.