le ';' indique toute fin d'instruction, affectation ou déclaration.

les variables simples sont des scalaires et commencent pas le signe $ comme en BASIC.

$nom="François";
$age=33;

On peut toujours utiliser printf exactement comme en langage C, bien qu'on ne puisse considérer le typage de la même manière.

printf("Mon nom est %s\nJ'ai %d ans\n",nom,age);

pour passer une commande externe : on peut utiliser la fonction system.

$cmd='dir /s /a *.txt';
system($cmd);
# ou encore, la forme à plusieurs paramètres
system('dir' ,'/s','/a' , '*.txt');

Si l'on souhaite récupérer le flot d'affichage d'une commande, il est préférable d'utiliser les quotes inverse : ` (ALT_GR +7 ) sur le clavier. notez qu'il faut parfois y ajouter la touche espace car dans certains systèmes ce caractère ne s'affiche pas directement.

my @liste_fichiers = `ls -1 -t -r`;
 foreach  (@liste_fichiers){
  ...;
 }
#un simple scalaire : rechercher perl sous linux
my $perl = `which perl`;
chomp($perl);
print "$perl\n";

2.2 Structures du langage Perl

Les variables simples sont les scalaires et commencent par '$'.

il existe 4 structures de données spécifiques :

1. le scalaire noté : $chaine, $n

   
   

2. la liste noté : @liste

   
   

3. le hash noté : %hash

   
   

4. le typeglob, noté : *F

Les typeglobs sont une sorte d'équivalences de symboles un peu comme les macros en C mais assez différents et plus subtils.

Perl est entièrement bâtit sur ces structures simples, et c'est avec l'interaction des ces structures entre-elles que l'ont peut créer des objets de données plus ou moins complexes.

2.2.1 déclaration et portée lexicale

Toute variable perl devrait être déclarée avec l'un des modificateurs de portée existant en Perl et notamment avec my.

voici les mot clés de déclaration possible:

my déclare les variables en les rendant accessibles à tout le bloc ET TOUS SES BLOCS INTERNES sauf si une variable de même nom est déclaré dans un sous-bloc, ce que l'on évite en général, mais qui est permis.

my protège ainsi les variables en limitant leur portée lexicale, c'est à dire leur visibilité, au blocs internes, ceci permet plus facilement de les protéger, et de déclarer des variables temporaires à la volée, par exemple des incréments de boucle.

L'instruction:

 use strict;

En début de programme rend obligatoire la déclaration des variables avec my, our ou local et force ainsi à définir leur portée lexicale.

our déclare une variable globale : elle sera visible dans tout le code, y compris dans le cas de l'import d'un module.

Il est possible par la suite de rendre une variable globale locale à un bloc {} au moyen du mot clé local mais aujourd'hui ceci est rarement utilisé, disons seulement pour des variables spécifiques à perl et intrinsèquement globales comme $_ par exemple ou encore des descripteurs de fichier : typeglobs ou des opérations sur la table des symboles de perl. en sortant de son bloc, la variable retrouvera la valeur qu'elle avait avant d'entrer dans le bloc.

2.3 Les scalaires

Les scalaires sont les variables simples de perl elles commencent toujours par le signe '$'. Elles peuvent contenir des nombres de toutes sortes et des chaînes de caractères mais aussi des références que nous verrons par la suite.

my $i=3; #Un nombre
my $str='xxxk34';
my $code='wait for me';

Simple et doubles quotes:

Les simples quotes produisent une affectation stricte

Les doubles quotes permettent l'interpolation.

$nom='marcel';
print 'mon nom est $nom' . "\n";
print "mon nom est $nom" . "\n";

2.4 Gestion des opérateurs sur scalaires

opérateurs d'incrémentation : ++ et +=

$n=2;
print "$n\n";
$n++;
print "$n\n";
n+=7;
print "$n\n";

#opérateurs de concaténation de chaînes : . et .=

my $chaine='mon chapeau';
$chaine = $chaine . ' est joli ';
print "$chaine\n";
for (0 .. 10){
 $chaine .= " ya de l'echo "
}
print "$chaine\n";

2.4.1 fonctions chop et chomp

2.4.1.1 chop

my $chaine="chaine";
print "|$chaine|\n";
chop($chaine);
print "|$chaine|\n";

2.4.1.2 chomp

my $l="ligne\n";
print "|$l|\n";
chomp($l);
print "|$l|\n";

2.4.2 sortie écran STDOUT

Comme nous l'avons déjà vu la sortie écran se fait au moyen de print ou de printf.

Il est aussi possible comme en script shell de faire de « l'inline document» ou « heredoc ».

exemple :

print<< "EOF";
Je vous l\'avais dit que ce cours  serait long.
cela fait quand-même déjà $n
heures que nous y sommes.
EOF

Notez que si vous mettez écrivez la balise de fin après le print entre quotes, vos variables seront interpolées CAD que ce sera leur contenu qui apparaîtra. Si vous écriver EOF entre simple quotes, tout sera littéral et les variables ne seront pas interpolées.

Notez qu'il est possible de faire de l'"inline document" ou "HereDoc" en affectant une variable, nous verrons cela avec le module DBI pour les requêtes SQL, mais en voici déja un simple exemple:

my $client = 'DUPONT'
my $sexe = 'Monsieur';
my $kg=3;
my $fruit='bananes';
my $message = << "EOF";
$sexe $client a acheté $kg kilos de $fruit
EOF
print $message;

STDIN (que nous avons déjà vu) pour l'entrée, capte ce qui est saisi par l'utilisateur ou un pipe, par exemple :

dir  | monprog.pl.

STDIN lira alors le résultat de la commande dir comme suit:

while (<STDIN>)
{
 ...
}

print et printf écrivent dans STDOUT.

les erreurs sont écrites dans STDERR.

Il faut considérer que l'affichage sur la sortie écran est possible car tous ces flux sont ouverts systématiquement par tout processus de programme Perl au début de son exécution sans que nous ayons à le faire.

Notez que ceci est le cas pour la plupart des langages de programmation.

2.4.3 impression

L'impression dépend fortement du système d'exploitation utilisé et Perl ne peut intervenir que comme composant externe en écrivant dans un périphérique, un flux, un pipe ou une combinaison de ces ressources. Rien n'interdit d'utiliser la commande système pour le faire.

Par contre il existe des et il est même conseillé d'utiliser des Modules qui permettent d'assurer la portabilité de l'impression en Perl, citons pour Windows le module Win32::Printer dont nous parlerons au troisième cours.

2.5 Les listes et tableaux

création et affectation.

@legumes = ('carotte','choux','navet','salade');
@fruits
                 = qw(pommes bananes oranges fraises poires);
$fruits[5]='cerise';
@fruits    = split(' ', 'pommes bananes oranges fraises poires');
#concaténation
@fruits_et_legumes=(@fruits,@legumes,('citron','pastèque'));

parcourt au moyen de foreach:

foreach my $fruit (@fruits_et_legumes){
  print "$fruit\n";
}

parcourt à l'aide des indices:

for my $i (0 .. $#fruits_et_legumes){
 print "$fruits_et_legumes[$i]\n";
}

parcourt avec for (test le nombre d'éléments à chaque tour de boucle)

for (my $i=0;$i<@fruits_et_legumes;$i++){
  print "$fruits_et_legumes[$i]\n";
}

2.6 Les tests

2.6.1 Tests simples

Les accolades de blocs sont toujours OBLIGATOIRE pour les tests en Perl,

contrairement à la plupart des autres langages.

if (<condition>){
  instruction(s);
}
elsif (<condition>{
  instruction(s);
}
elsif (<condition>) {
  instruction(s);
}
else{
 instruction(s);
}

2.6.1.1 Les Comparaisons numériques

Ce sont les opérateurs habituels qu'on trouve en C et tous les langages qui en découlent:

2.6.1.2 Les comparaisons alphabétiques sur les chaînes :

2.6.2 Les tests séquentiels

Ne perdez pas de vue le fait que parfois, toutes les expressions doivent être exécutées afin d'opérer un traitement dans votre programme, même si elles renvoient faux, et dans ce cas il faudra utiliser la forme simple de | ou de &.

2.7 Les boucles : définies et indéfinies

Boucle incrémentale classique.

for(my $i=1; $i<$max;$i++){
...
...
}

Pour les listes on utilise foreach

foreach (@liste){
 print  "$_\n";
 $_ = ($_ . 'x');
 $_ .= 'x';
}

On peut aussi utiliser des intervalles

my $max=12;
 for (0 .. $max){
 print "$_\n";
}
for $n (3 .. 7) {
 print "$n\n";
}

2.7.1 Structures de boucles

2.7.2 Les instructions de contrôle des boucles

2.7.2.1 next

Next saute un tour de boucle, exemple :

#!/usr/bin/perl -w
my $cherche = '/usr/local';
my $resultat;
open(F,"/etc/fstab");
my @lines=(<F>);
foreach (@lines){
chomp();
next if /^#/;
next if /^\s*$/;
#Les 2 next précédents fond des rejets
my ($part,$dir,$type,$args) = split('\s+');
  if ($dir eq $cherche){
   $resultat=$_;
   last;
  }
}
print "$resultat\n";

2.7.2.2 last

last met fin à une boucle, exemple :

#!/usr/bin/perl -w
my $cherche = '/usr/local';
my $resultat;
open(F,"/etc/fstab");
my @lines=(<F>);
foreach (@lines){
chomp();
next if /^#/;
next if /^\s*$/;
my ($part,$dir,$type,$args) = split('\s+');
  if ($dir eq $cherche){
   $resultat=$_;
   #La boucle va s'arrèter!!
   last;
  }
}
print "$resultat\n";

2.8 Les instructions de branchement

Les instructions de branchement utilisent les labels au moyen d'une instruction qui peut être goto, next ou last. Un label est un simple mot suivi du caractères : On a coutume de les définir entièrement en lettres majuscules.Avec last et next suivis de labels.

Exemple:

#!/usr/bin/perl -w
EXTERIEUR:
 for ( $i = 1; $i <= 10; $i++)
  {
    INTERIEUR:
    for ( $j = 1; $j <= 10; $j++)
         {
           if ( $i * $j == 63 )
           {
             print "$i fois $j égal 63 !\n";
             last EXTERIEUR;
           }
          if ( $j >= $i )
          {
            next EXTERIEUR; }
          }
   }

2.8.1 L'instruction goto

Elle permet tout simplement de se rendre à une étiquette.

#!/usr/bin/perl
$count = 0;
START:
$count = $count + 1;
if( $count > 4 ){
         print "Exiting program\n";
}else{
    print "Count = $count, Saut vers START:\n";
    goto START;
}

Produit ce résultat

Count = 1, Saut vers START:

Count = 2, Saut vers START:

Count = 3, Saut vers START:

Count = 4, Saut vers START:

Exiting program

Évitez l'abus de goto dans vos programmes et surtout évitez ce genre de choses par exemple:

sckizo.pl

if (condition) {
LABAS:
  instruction(s);
}
else {
goto LABAS;
}

2.9 Les instructions abrégées

(expression) ? (faire ceci) : (faire cela);

Ceci est issu de nombreux langages dont le C à l'origine et a été porté en perl.

La première expression est un test, si le résultat du test est vrai, l'instruction juste après le ? sera exécutée, sinon c'est celle après le : qui sera exécutée.

Avec le conditionnel, on trouve souvent ces instructions abrégées.

Lorsque la condition ou l'instruction est courte, cela permet de raccourcir l'écriture et de se passer des accolades de blocs.

instruction if condition;
next if (condition); 
last if  (condition);
next until (condition);
last until (condition);

2.10 Les tableaux associatifs ou hachage

Les hash sont des tableaux dont les indices peuvent être du texte. tout indice est unique et constitue une clé. A chaque clé on associe une valeur.

#déclaration
my %monhash;
#affectation 
$monhash{'age'}=33;
$monhash{'nom'}='Jean';

Affectation et déclaration directe

#déclaration
my %monhash;
#affectation 
$monhash{'age'}=33;
$monhash{'nom'}='Jean-Yves';

 #Relecture avec keys :
 foreach my $k (keys %monhash){
   print "$k => $monhash{$k}\n";
 }
#Relecture avec each
while ( my($k,$v) = each(%monhash)){
   print "$k => $v\n";
}

values renvoie la liste des valeurs;

my @valeurs = values %monhash;

2.10.0.0.1 Conséquences et propriétés particulières des hashs :

1. Chaque indice constitue la clé d'une valeur.

2. Les clés sont uniques au caractère prêt (dépendant de la case). : Les clés 'macle' et 'Macle' sont 2 clés distinctes.

3. Les clés sont indexées : cela signifie que leur accès mémoire est instantané, quel que soit leur nombre.

4. Après relecture (avec keys) l'ordre des clés est désordonné.

2.11 Gestion des fichiers et des répertoires

2.11.1 Les entrées/sorties : saisie

print "Programme indiscret.\n";
$merci="Merci pour ces informations\n";
print "Donnez votre nom : ";
$nom=<STDIN>;
print "Donnez votre age : ";
$age=<STDIN>;
printf("%s\nVous vous appelez %s et vous avez %d ans.\n",
$merci,$nom,$age);

2.12 Traitement sur les fichiers : lecture, écriture, informations.

2.12.1 Ouverture en lecture

2.12.1.1 ouvrir un fichier:

open(FILE,'/chemin/vers/fichier.txt');

Pour contrôler la réussite ou non de l'ouverture, on peut utiliser die et $! :

my $file = '/chemin/vers/fichier.txt';
open(FILE ,$file) or die ''Ne peut ouvrir $file : $!'';

Lecture :

while(<FILE>)
{
  print;
}

Fermeture:

close(FILE);

Note : toute fin du programme ferme tous les flux ouverts et lorsqu'on ré-ouvre un même flux avec un nom de fichier différent, le fichier précédent est aussi fermé automatiquement.

Conseil: parfois il vaut mieux fermer un flux 2 fois que pas du tout.

2.12.1.2 Ouvrir un pipe:

my $cmd = "ipconfig /all";
open(PIPE,"$cmd |") or die "Ne peut ouvrir le pipe sur $cmd : $!";
while(<PIPE>){
...;
...;
print "$_\n";
}

Il convient de ne pas oublier de fermer le pipe:

close(PIPE);

sinon vous risquez un comportement étrange de votre programme avec des bugs subtils.

2.12.2 Ouverture en écriture

2.12.2.1 ouvrir un fichier en écriture:

open(FILE ,''>/chemin/vers/fichier.txt'');

Avec die et $! : pour le contrôle des erreurs:

my $file = '/chemin/vers/fichier.txt'';
open(FILE ,''>$file') or die ''Ne peut ouvrir $file : $!'';

Ecriture:

print FILE ''J\'écris dans le fichier\n'';
print FILE ''Tant que celui-ci est ouvert\n'';
close(FILE);

2.12.2.2 Informations sur les fichiers

2.12.2.2.1 Les tests

my $file = 'c:/mesprogrammes/essai.pl';
if ( -d 'c:/mesprogrammes' ) {
   if (-e 'c:/mesprogrammes/essai.pl') {
      print  "Le fichier existe OK";
  ...
  }
  else {
          print "Le fichier c:/mesprogrammes/essai.pl n'existe pas"
         }
}
else {
  print "Le répertoire \"c:/mesprogrammes\" n'existe pas ou n'est pas un répertoire.\n";
}

2.12.2.2.2 La fonction stat donne toutes les informations sur un fichier

documentation perlfunc : fonction stat

La fonction stat renvoie une liste de 13 champs contenant toutes les informations relatives à un fichier.

my ($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,
        $atime,$mtime,$ctime,$blksize,$blocks)
            = stat($filename);

on peut choisir seulement les champs que l'on désir comme suit:

@stats=stat($filename);
my ($size,$mtime,$blksize)=@stats[7,9,11]

Ce qui peut être fait en une seule ligne:

my ($size,$mtime,$blksize)=(stat($filename))[7,9,11]

2.12.3 Répertoires

2.12.3.1 Création

Tout répertoire peut se créer avec la commande mkdir, qui est intégrée à Perl.

2.12.3.2 Lecture au moyen de Opendir et readdir

opendir(DIR,"c:/perl/lib") or die "Ne peut ouvrir $dir : $!";
my @files=readdir(DIR);
foreach my $fichier (@files){
  print ''$fichier\n'';
}
#Notez  que readdir renvoyant une liste peut être invoqué par le
#foreach directement
sans la liste temporaire @files
foreach  my $fichier (readdir(DIR)){ .. }

2.13 Les références : sur tableaux et anonymes

my $scalaire = 'du texte';
my $ref_scalaire=\$scalaire;

déréférencement:

print $$scalaire . "\n";

Pour une liste:

my $ref_liste = \@liste;

foreach (@{$ref_liste}){
   print "$_\n";
}

Pour un hash

my %h = ( age => 30,
prenom => 'Jean',
nom => 'DURANT');
my $ref_hash=\%h;
foreach my $one (keys %{$ref_hash}){
 print "$one => $ref_hash->{$one}\n";
 print "meme chose : $one => $$ref_hash{$one}\n";
}

Voiçi maintenant un exemple de création de hash, et liste anonyme:

#!/usr/bin/perl -w
use strict;
#hash anonyme
my $h = {};
print $h . "\n";
$h->{toto}=1;
$h->{titi}=33;
print Dumper($h);
#tableau anonyme
my $l= [];
print $l . "\n";
push(@$l,qw(toto titi tata momo lolo coco));
foreach  my $one (@{$l}){
 print "$one\n";
}

2.13.1 Documents Perl relatifs aux références

http://perl.enstimac.fr/DocFr/perlref.html

http://perl.enstimac.fr/DocFr/perllol.html : liste de listes

perldsc - Livre de recettes des structures de données en Perl

3 Variables pré-définies de Perl

Perl définit possède un nombre impressionnant de variables prédéfinies, elles permettent de rendre beaucoup de choses implicites et rendent le langage beaucoup plus puissant.

D'autres permettent de donner des informations, ou de modifier le comportement par exemple '$/' configure le séparateur des enregistrements en entrée.

En voici les principales:

3.1 Scalaires prédéfinis

Notez que je n'ai pas inclus les variables prédéfinies relatives aux expressions rationnelles.

Nous les verrons lors de l'étude du chapitre.

3.2 Liste et hashs prédéfinis

Note : pas de nom long.

Vous trouverez une liste plus complète dans la documentation officielle de Perl :

perlvar - Variables prédéfinies en Perl

Et sur ce site avec des exemples simples :

http://fr.selfhtml.org/cgiperl/langage/predefini.htm

Le but étant de connaître les plus importantes, $_ et @_ sont incontournables.

4 Les expressions rationnelles

4.1 Description

Issu des mathématiques des langages formels des années 45/50, elles permettent d'analyser formellement du texte.

Le principe est la création de motifs d'expressions rationnelles au moyen de symboles élémentaires suivis eux-même de symboles de répétitions; les seconds complétant les premiers et ce chapitre contient deux tableaux les décrivant.

4.1.1 documentation perl à consulter

La documentation Perl décrit les expressions rationnelles dans ces 4 fichiers, il faut bien entendu commencer par le plus simple et ceci vient en complément du cours.

4.1.2 Note

Ce chapitre peut sembler abstrait et/ou trop théorique si vous n'avez jamais fait d'expressions rationnelles. Attendez d'arriver a la fin du point 4 , point ou vous devrez mettre la théorie en pratique par vous-même, et n'hésitez pas à poser vos questions à ce moment.

4.2 Symboles élémentaires

Ils permettent de définir un caractère et un seul à un emplacement donné dans la séquence du motif. Ce caractère pouvant être abstrait comme le début de ligne ^ ou sa fin $. Il peut être aussi indéfini comme '.' ou faire partie d'un groupe (range) que l'on peut aussi appeler classe, exemple : [A-Za-z] défini une lettre de l'aphabet majuscule ou minuscule.

Notez que La norme POSIX définit en plus, des classes prédéfinies permettant de construire des ensembles courants et utiles sans écrire une suite interminable de lettre entre crochets par exemple [:alnum:] définit un ensemble aphanumérique. Notez les ':' avant et après. Pour des raisons de simplicité, je n'ai pas souhaiter les décrire içi.

Vous trouverez l'ensemble de ces classes dans la documentation Perl traduite :

perlreref - La référence pour les expressions rationnelles en Perl

et se rendre à la section "CLASSES DE CARACTERES".

Dans le tableau ci-dessous les principaux symboles à connaitre.

4.3 Symboles de répétitions

Afin de constituer le motif, chaque caractère qui est définit au moyen d'un symbole ou d'une classe décrit dans le tableau précédent peut être répété un certain nombre de fois. Là encore la symbolique peut décrire un nombre abstrait de répétitions: * signifie entre 0 et x fois, + entre 1 et x fois, etc...

Notez que toutes ces répétitions peuvent aussi s'appliquer sur des regroupement entre parenthèses constitués de suites concrètes lettrées et/ou des motifs même d'expressions rationnelles plus ou moins complexes.

4.4 Les motifs

Les deux tableaux précédents décrivent l'essentiel afin de pouvoir construire des motifs plus ou moins complexes.

En perl le motif est entouré des caractères / en général mais il peut être remplacé par un autre pour convenance.

exemple d'un motif de base avec recherche dans $_

foreach (@liste){
  unless (/^\s*$/)
  {
    print "$_\n";
  }
}

Quant la recherche se fait sur une variable : on utilise = suivis du tilde : ~

foreach my $ligne (@liste){
 unless ( $ligne =~ /^\s*$/){
  print "$_\n";
 }
}

Le séparateur peut changer pour convenance, on place la lettre (m : match) devant dans ce cas:

my $full_filename='/usr/local/bin/codeblocks';
if  ($full_filename =~ m#^/([^/]+/){3}([^/]+)#){
$file=$2;
}
#dans une boucle de lecture de fichier : réjection
while (<>){
#saute la ligne si elle contient une suite d'espace éventuels,
#suivis de 3 '-' ou plus, ces lignes ne seront pas affichées
next if /^\s*-{3,}/;
print "$_\n";
}

4.5 substitution

s/<expression_rationnelle>/<remplacement>/[modificateur]

L'opérateur de substitution est s, il possède 3 séparateurs '/' dans l'exemple ci-dessous. Le motif d'expression rationnelle se trouve entre le premier et le second séparateur et par quoi le remplacer entre le second et le troisième. Dans notre exemple, le remplacement est vide, ce qui revient à supprimer la partie matchée par le motif.

Note : La fin de la substitution peut être suivie d'un modificateur (une lettre) qui va comme son nom l'indique modifier le comportement de l'instruction , dans un permier temps, nous ne verrons que le modificateur 'g' dans ces exemples qui indique à perl de substituer toutes les occurrences de la ligne car par défaut seule la première est substituée.

Voici quelques exemples de substitution:

while (<>){
#supprime toute suite de nombre en début de ligne
s/^([0-9]+)//;
#change le premier  'e' en 'E'  dans la ligne.
 s/e/E/;
#Change tous les bateau en chapeau dans la ligne
#(notez le modificateur 'g' a la fin du motif)
 s/bateau/chapeau/g;
#changement des '/' en '\' , les '\' doivent être protégés par l'antislash.
s/\//\\/g;
#Strictement identique,
#Mais pour des raisons de bon sens, le séparateur peut-être est changé en ','
# l'antislash étant un méta-caractère, il doit être protégé par l'antislash-lui même, c'est
#pourquoi il est doublé, le fait de changer le séparateur rend le motif beaucoup plus lisible
#dans ce cas
s,/,\\,g;
}
 $full_filename = '/usr/local/bin/codeblocks';
 $full_filename =~ s,^/([^/]+/){3},,;
#substitue afin de ne garder que 'codeblocks'

4.6 Les modificateurs

La fin d'un motif de match ou de substitution peut être suivie d'un ou de plusieurs modificateurs qui peuvent changer considérablement l'action opérée.

Voiçi la pluspars des modificateurs utilisés et leur signification:

4.6.1 Les regroupements

voiçi un exemple de regroupement, extractions des champ d'une date et heure:

#!/usr/bin/perl -w
#exemple de regroupements
my $str="12/02/2008 10:33:42";
if ( $str =~ m{([0-9]{2})/([0-9]{2})/([0-9]{4})\s([0-9]{2}):([0-9]{2}):([0-9]{2})}){
#On retrouve les parties machées dans les variables spéciales $1, $2 ... $<n>
 my ($jour,$mois,$annee,$heure,$minute,$seconde) = ($1,$2,$3,$4,$5,$6);
 print join("\n",($jour,$mois,$annee,$heure,$minute,$seconde)) . "\n";
}

Ici les regroupements concernent des chiffres, on récupère chaque regroupement dans les variables $1 $2 $3 , et dans l'ordre des parenthèses ouvrantes.

Ceci est très pratique pour faire des extractions spécifiques. Notez que les regroupements peuvent être imbriqués.

4.6.2 Variables prédéfinies pour les expressions rationnelles.

Perl définit des variables spéciales qui s'affectent automatiquement lorsqu'une expression rationnelle est exécutée.

En voici la liste et le rôle de chacune:

ATTENTION : ces variables sont affectée lors de l'exécution de l'expression rationnelle, mais dites-vous bien qu'elle correspondent à la dernière expression rationnelle exécutée. Cela signifie que vous toute nouvelle expression rationnelle écrasera la dernière valeur.

Une forme avec le flag e par exemple exécute une expression dans la substitution et si cette expression appelle une sub qui fait elle-même du matching, vos variables seront modifiées par la dernière expression rationnelle rencontrée.

De plus si vous ne testez pas la réussite (ou non) de votre expression rationnelle (au moyen de if), vous aurez peut-être quelques-chose dans $& , $1 and co, mais cela ne prouve pas que votre matching aura réussit: ce seront les dernières valeurs affectées par la dernière expression rationnelle exécutée 20 lignes plus haut par exemple.

A ce titre, voiçi par exemple ce qu'il ne faut pas faire:

while (<FILE>){
chomp;
/mon bateau, le ([\w]+)/; #recherche le nom du bateau
$nom_bateau = $1;
}

Car si l'expression échoue, rien ne dit que $1 sera affectée, pire $1 peut être affectée par une expression rationnelle lancée 100 lignes plus haut et contiendra n'importe quoi.

if vaut mieux écrire ceci:

while(<FILE>){
chomp;
my $mon_bateau;
if (/mon bateau, le ([\w]+/){
 $nom_bateau = $1;
}

4.7 fonctions split et join

4.7.1 documentation Perl à consulter

perlfunc - Fonctions Perl prédéfinies

Notez que ce fichier est gros car il contient la description de toutes les fonctions perl prédéfinies c'est à dire compilées dans l'interpréteur, et ne faisant appel à aucune librairie externe. Il convient donc d'y faire une recherche textuelle dans ce gros fichier afin d'y trouver ce que l'on cherche.

4.7.2 La fonction split

Split éclate une chaîne de caractères d'après un motif d'expressions rationnelle.

split([<motif>,[chaîne]],[limite]);

Elle retourne sous forme de liste, toutes les occurrences comprises autour des séparateurs trouvé.

A noter que les champs vides en dernier sont supprimés. Ceci peut être contourné en imposant un nombre d'éléments au tableau retourné au moyen du troisième paramètre : limite.

Limite peut aussi limiter le nombre de champs lorsqu'il y en a trop pour nos besoins.

Dans le cas ou aucun champ n'est vide, le nombre des éléments sera égal aux nombre de séparateur +1 (règle des poteaux et des intervalles).

La chaîne par défaut est $_ et le séparateur par défaut est une suite de blanc correspondant au motif suivant /^\s+$/

Split a en principe un tableau comme lvalue (valeur de gauche avant le =) mais si l'on lui donne un simple scalaire, il renvoie le nombre d'éléments qu'il a trouvé dans la chaîne. Ce qui peut être utile pour les compter.

exemples:

#!/usr/bin/perl -w
while (<>){
 chomp;
 @res=split(/\s+/);
#compte le nombre d'éléments.
 my $nb_elements=split(/\s+/,$_);
my $n=0;
  foreach my $one (0 .. $nb_elements){
  # opère un traitement pour chaque champs éclatés.
    print "$res[$one] element $one , $nb_elements total.\n";
  }
}
while (<>){
my ($nom,$age) = split(';',$_,2);
print "$nom;$age\n";
}

4.7.3 La fonction join

Join fait l'inverse de split : il prend un tableau et constitue une chaîne de caracteres en sépararant chaque élément du tableau par le séparateur donné en argument.

my $file='monfic.csv';
open (CSV,$file) or die "Ne peut ouvrir $file : $!";
while (<CSV>){
  chomp();
  my ($nom,$prenom,$age) = split(';',$_,3);
  #passe en majuscules la première lettre du prénom
  $prenom =~ s/^([a-z])/uc($1)/e;
  #passe en majuscules toutes les lettres du nom
   $nom      =~ tr/[a-z]/[A-Z]/;
   #reconstitue la chaîne initiale
   $_= join(';',($nom,$prenom,$age)) . "\n" ;
   #Affiche la chaîne initiale
   print;
}

4.8 Utilisation interactive de l'interpréteur Perl

4.8.1 Pas vraiment de mode interactif

La méthode officielle pour le faire est d'utiliser le débuggeur ainsi:

perl -d -e 1

Ainsi vous serez façe à un shell et toutes les commandes perl que vous tapez seront exécutées à chaque saisie de la touche <ENTREE>.

Il n'est toutefois pas très compliqué de réaliser ce genre de programme étant donnée la puissance de Perl.

Néammoins, notez qu'il n'est pas simple d'obtenir un interpréteur sûr et de qualité.

4.8.1.1 Alternatives

psh : un shell perl dans le sens de permettre l'exécution de commandes systèmes en passant par le shell.

perlconsole: un programme sophistiqué permettant un vrai mode interactif, à notez que ce programme utilise des modules perl externes pour fonctionner.

Il en existe d'autres, dont certaines sous forme de librairies plus ou moins sophistiquées.

Note: Il est étrange que Perl n'ai pas un mode natif pour ce genre de chose comme python par exemple.

4.8.2 Débogage

L'option -d de Perl est surtout utilisée pour le débogage.

perl -d monprog.pl

permet de lancer monprog.pl en mode débogage. Cela signifie que vous verrez un shell vous invitant à entrer des commandes.

Ainsi, votre programme ne sera lancé que si vous le demandez et vous pourrez faire un tas d'action de contrôle et d'analyse sur l'exécution de votre programme.

Les commandent consistent en une seule lettre suivie de la touche <ENTRER>.

La première commande que vous pouvez lancer est 'h' qui vous affichera une description de l'ensemble des commandes existantes et leur action.

Notez qu'utiliser le débogeur ainsi est assez drastique. Néanmoins ce n'est pas une mauvaise chose car avec de l'habitude vous trouverez vos repères et vous n'aurez besoin de rien d'autre.

Il existe des interfaces (notamment en python) qui permettent de rendre cette utilisation plus conviviale, mais c'est une nécessité supplémentaire que vous n'aurez pas toujours à votre portée.