Le langage PERL, résumé

Documentation et apprentissage

Avertissement : ces notes ont accompagné un auto-apprentissage de PERL. Elle n'ont donc aucune prétention pédagogique.
Le livre de référence abordable pour un débutant en PERL me semble être :
Introduction à PERL, par R.Schwartz & T.Christiansen (O'Reilly éd.)
La documentation complète est en cours de traduction en Français. Voir http://www.enstimac.fr/Perl/
Un cours de O.Aubert (Ecole Télécom Bretagne) à http://www.linux-kheops.com/doc/perl/perl-aubert/html/perl.html

Caractéristiques générales

Structures de données

Il y a 5 sortes de variables, dont le statut est différenciable grâce à un symbole préfixé différent.

type de variable préfixe
scalaire $
tableau (liste) @
associative (hachage) %
fonction (routine)) &
fichier (handle) sans

Variables scalaires

  1. Identificateurs précédées du symbole $.
    Les variables scalaires peuvent être des nombres (entiers, flottants), des chaînes (ou des références de fichier)
    Le variables n'ont pas de type. Elles sont interprétées comme chaîne , nombre ou booléen suivant leur affectation ou le contexte. En général, la conversion entre chaîne et nombre est transparente.
    Par exemple : 
    $a = '24' ;  # $a est une chaîne
print $a + 1, "\n"; #affiche 25 ! attention pas de " "
    Il n'y a pas de variable de type booléen. Mais en revanche une valeur scalaire peut être interprétée comme la valeur booléenne vraie (TRUE) si ce n'est pas une chaîne vide ou le nombre 0 ou la chaîne "0". 
    $x= 0.75;
$n= 123;
$y= 1.6e-19;
$octal= 015; #caractère retour-chariot 
$hexa = 0xff; # vaut 255
$a=200; $b=350 ; $s= $a + $b;

  2. Les chaînes sont délimitées soit par " " soit par ' '.
    Dans le cas des guillemets, les variables incluses sont interprétées (on dit interpolées dans le jargon Unix) et remplacées par leur valeur. 
    $monNom ="Jean"; 
$salut = "Bonjour $monNom" ;
print $salut;    affiche bien Bonjour Jean !
$s = 'Bonjour $monNom !' ;            
print $s;    affiche par contre Bonjour $s 

$a=200; $b=350 ; 
# affiche $a + $b = 200 + 350 = 550
print '$a + $b', " = $a + $b = ",  $a + $b , "\n";

  3. Utilisation de chaînes multilignes
    On peut définir des chaînes sur plusieurs lignes
    On utilise pour cela un identificateur (ici ESSAI) qui sert de délimitateur. 
    #!/usr/bin/perl 
$texte = <<"ESSAI"; 
Bonjour a tous ! 
ceci est un essai 
de texte multiligne 
ESSAI 
print $texte;
    Ceci est très utilisé pour générer du code HTML à renvoyer au client Web 
    print <<"marqueur";
<body>
<h1>Voici un site WEB sur
<a href="http://www.ac-creteil.fr/infolyc/linux/formation">linux</a>
</h1>
</body>
marqueur

  4. Variables spéciales prédéfinies

  5. La variable standard entrée
    $ligne=<STDIN> stipule de lire une ligne sur l'entrée standard jusqu'au caractère de validation \n, et l'affecte à la variable $ligne, y compris \n 
    $ligne = <STDIN>;
chop($ligne);
print "La ligne saisie est : $ligne " ;
    <STDIN> en l'absence d'affectation explicite, c'est la variable $_ qui reçoit la ligne entrée.
    print "Pour sortir de la boucle Ctrl-C\n";
$i=0 ; # compteur de boucle
while <STDIN> {
chop($_); i++ ;
print "La ligne $i est : $_ \n" ;
}

  6. Simulation de booléen
    Il n'y a pas de variable de type booléen, mais on peut facilement utiliser à la place une variable numérique. En effet toute expression en situation de test (conditionnelle, boucle) valant 0 ou "0" ou undefined est considérée comme fausse, toute autre valeur est considéré comme vraie ! 
    $trouve=0  # trouve est fausse
while (!$trouve) { # !$trouve = 1 
 if (....) {
 trouve = 1 ; # trouve devient vraie 
 }
}

Les listes ou tableaux

Listes associatives (ou hachages, dictionnaires)

Opérateurs et expressions

Opérateurs scalaires

  1. # de concaténation 
    print "salut"." jean";  # affiche "salut jean"
  2. # puissance et affectation 
    $x **=3; # $x=8
  3. # répétition d'une chaine 
    print "jean " x 10; #affiche "jean" 10 fois ...
  4. # affectations multiples 
    $a = $b = $c = 5;
$d = $a +($e = 10); # $e = 10 et $d = 15
  5. # opérateur incrémentation 
    $a = $b = 5;
$c = ++$a; # $c = $a = 6
$d = $b++; # $d = 5 et $b = 6
  6. # les opérateurs chop() et chmop() chop retire le dernier caractère de la chaine et retourne ce caractère 
    $b= "Bonjour à tous";
$a = chop($b); $b = "Bonjour à tou" et $a ="s"
    chomp ne retire qu'un caractère nouvelle ligne "\n", sinon rien.
  7. une instruction peut être suivi d'une expression modificatrice comme if, while ... Qq exemples /
    1. La fonction defined renvoie 1 (donc "vrai") si la variable qui suit est bien définie
      print "Erreur, nom non défini !\n" if ! (defined $nom);

Opérateurs et fonctions tableaux

On peut utiliser la structure tableau pour accéder différemment aux éléments de début ou de fin.

Comportement "pile" avec les fonctions push (empiler) et pop (dépiler) 

@liste =(1..3);
push (@liste, 4 , 5);   # on peut empiler plusieurs valeurs, @liste=(1..5)
$val = pop (@liste); # donne $val=5 et @liste=(1,2,3,4)
Accès en début de liste avec les fonctions shift et unshift 
@liste =(1..4);
unshift (@liste, 7);  # insére $val en élément 0, donne @liste=(7,1,2,3,4)
$valeur = shift (@liste);  # comme ($val, @liste)=@liste, donne $val=7  et @liste=(1..4)

Structures de controle

Le vrai et le faux

Les opérateurs de comparaison

Opérateurs sur ChaînesNombres
Égalité eq ==
Différentne !=
Inférieur lt <
Supérieur gt >
Inférieur ou égal le <=
Supérieur ou égal ge >=
Comparaison cmp <= >
Opérateurs booléens
et &&
ou ||

L'opérateur de comparaison cmp pour les chaînes renvoie -1, 0 ou 1 selon que le premier argument est inférieur, égal ou supérieur au second.

instructions if et unless

Même syntaxe qu'en C ou en Java, à la différence que les accolades sont toujours obligatoires
Exemple 
print "Quel est votre âge : ?"
$age = <STDIN>;        # lecture clavier 
chomp($age);
if ($age < 18 ) {
   # ou unless ($age >= 18 )
   print("Vous êtes trop jeune pour voter!\n");
} else {
   print("Vous pouvez voter!\n"); 
   $inscrits++     # compte les inscrits au vote
}

Imbrication des conditionnelles

Elle est permise par la construction if .. elsif .. else 
if (test1) {
  instruction1
 } elsif (test2) {
   instruction2
 } elsif (test3) {
   instruction3
 } else { 
 # les 3 tests ont échoué
 instruction3
 }

instructions while et until

Syntaxe
while (condition) { 
 bloc
 }
until (condition) { 
 bloc
 }
Ces 2 boucles "tournent" tant que la condition demeure vraie (pour while) ou fausse (until).

Exemples d'utilisation

# boucle d'attente
while (<>) {
last;
}
# lecture d'une ligne entrée au clavier, puis affichage
while ($ligne=) {
print $ligne;
}

@nombres=(0..10);
print @liste,"\n";
print @lettres,"\n";print @nombres,"\n";$liste[5]=jean;print @liste,"\n";$i=0;

instruction for et foreach

controle de boucle : last et next

Exemple 
print "La demande sera arrêtée par la saisie de la lettre \"z\" ou \"Z\" \n";
while () {
chop($_);
if (($_ eq "z") || ($_ eq "Z")) { last; }
}

Les expressions régulières

Les modèles

Substitution de chaines par s/ / /

s/expression-reg /nvelle valeur /options Cet opérateur remplace les occurrences de l'expression dans la variable courante $_ 
if (/htm/) {
s/htm/html ;
print $_;
}
Pour une étude complète, voir perl-expr-regulieres.html

Entrées-sorties et manipulations de fichiers

Entrées-sorties standard

Opérateurs de tests sur les fichiers

Les fonctions