Introduction à PERL

Département Informatique
Laboratoires de système d’exploitation
Introduction à
PERL
par Louis SWINNEN
Ce document est disponible sous licence Creative Commons indiquant qu’il peut être
reproduit, distribué et communiqué pour autant que le nom des auteurs reste présent,
qu’aucune utilisation commerciale ne soit faite à partir de celui-ci et que le document ne soit
ni modifié, ni transformé, ni adapté.
http://creativecommons.org/licenses/by-nc-nd/2.0/be/
La Haute Ecole Libre Mosane (HELMo) attache une grande importance au respect des droits d’auteur.
C’est la raison pour laquelle nous invitons les auteurs dont une œuvre aurait été, malgré tous nos
efforts, reproduite sans autorisation suffisante, à contacter immédiatement le service juridique de la
Haute Ecole afin de pouvoir régulariser la situation au mieux.
Septembre 2010
1. Introduction
PERL est un langage de script très répandu dans le monde Unix et très populaire auprès des
administrateurs systèmes et réseaux. À coté de PERL, on trouve également PYTHON, autre
langage de script, très répandu également.
PERL est un langage interprété. En effet, c’est le code source du langage qui est lu par
l’interpréteur et qui est exécuté. Il est, par conséquent, portable. PERL est également
proche de la syntaxe de C. Ainsi, les programmeurs C peuvent facilement comprendre et
écrire des programmes PERL. PERL est également un langage de haut niveau dans le
sens où de nombreuses fonctions existent pour aider le programmeur : ainsi la manipulation
de chaînes de caractères, l’accès (ouverture, lecture, écriture) aux fichiers, l’exécution de
commande du système est simplifié en PERL. Ce langage a été longtemps utilisé pour écrire
des scripts Web (appelé scripts CGI) avant la généralisation de PHP.
Enfin PERL est un logiciel libre qui est disponible gratuitement sur internet. Aujourd’hui, on
trouve des implémentations sous GNU/Linux mais également sur la plupart des systèmes
UNIX (comme MacOS X, *BSD, Oracle Solaris, …) mais également sous Windows.
L’étude de PERL pourrait nous occuper longtemps … le but de cette petite introduction est
d’ouvrir une porte, libre au lecteur de se plonger dans ce langage s’il le souhaite. Beaucoup
de sites internet parlent de PERL, ainsi citons :
• http://www.perl.org, le portail officiel
• http://perl.enstimac.fr/, traduction en français de la documentation
• http://www.perl.org/books/library.html, quelques livres de référence dont certains
sont disponibles gratuitement en ligne
• http://www.lea-linux.org/documentations/index.php/Dev-perl,
site
LEA-LINUX
fournissant beaucoup d’information sur Linux et, introduisant PERL.
2. Concepts
2.1 Pour commencer
Pour commencer la rédaction d’un programme PERL, il faut disposer de deux choses :
• un éditeur texte
• l’interpréteur PERL
La plupart des distributions Linux fournissent ces deux composants. Prenez donc votre
éditeur texte préféré (comme Vim par exemple) et commencez la rédaction de votre
programme.
On commence la rédaction d’un programme PERL par les deux lignes suivantes :
#! /usr/bin/perl
use strict;
Voici comment il faut comprendre ces deux lignes :
• La première ligne indique que le texte qui suit doit être lancé par l’interpréteur PERL.
Le chemin par défaut est /usr/bin/perl. Vérifiez bien où se trouve votre
interpréteur.
• La seconde ligne mentionne que nous utiliserons le mode strict. C'est-à-dire que le
programmeur a l’obligation de définir toutes les variables avant de les utiliser. Cette
option est largement recommandée afin d’éviter les erreurs de typographies.
2
2.2 Les variables
PERL permet l’utilisation de 3 familles de variables. En effet, il y a :
• les variables simple ou atomique
• les variables multivaluées ou tableaux
• les variables représentant des tables hachées
Toute variable doit être déclarée grâce au mot clé my.
2.2.1 Les variables simples
Une variable simple se reconnaît facilement car son nom est préfixé par le symbole $. Ainsi,
voici la définition de plusieurs variables simples :
my $val = 2;
my $texte;
$texte = "Hello World\n";
La première ligne définit une variable simple, nommée $val et contenant la valeur 2. Les
deux lignes suivantes définissent une variable simple, nommée $texte. Ensuite, on lui
affecte le texte Hello World suivi du retour à la ligne.
2.2.2 Les tableaux
PERL permet de définir facilement des tableaux. Ces tableaux sont toujours dynamiques (on
ne mentionne jamais leur taille). Une variable tableau se reconnaît car elle est préfixée par le
symbole @. Ainsi voici la déclaration de tableaux :
my @tab;
$tab[0] = 5;
$tab[$val] = 4;
On remarque que :
• comme en C, le tableau débute à l’indice 0.
• à l’inverse de C, une chaîne de caractère n’est pas un tableau mais une variable
simple.
• l’accès à un élément s’effectue comme l’accès à une variable simple, au moyen du
symbole $.
On peut connaître la taille d’un tableau grâce au mot clé scalar. Par exemple :
my $taille = (scalar @tab);
PERL permet d’avoir accès à tous les éléments d’un tableau en extension. Par exemple :
my $flatten_tab = (@tab);
La variable simple $flatten_tab contient tous les éléments présents dans le tableau
@tab.
2.2.3 Les tables hachées
La table hachée est un outil puissant. PERL la rend très flexible. Une donnée représentant
une table hachée est préfixée par le symbole %. La fonction de hachage, le rangement et les
collisions sont gérées automatiquement par PERL, le programmeur ne doit jamais s’en
soucier.
3
La clé utilisée pour accéder / stocker un élément peut être numérique ou textuelle. Cela
permet une réelle flexibilité. Exemple :
my %hash;
$hash{"cle"} = 2;
$hash{$val} = "hello";
On remarque que :
• comme pour les tableaux, l’accès à un élément de la table hachée (qui contient une
donnée simple) se fait au moyen du symbole $
• dans l’exemple, cle est la clé d’accès à la table tandis que $val est une variable
simple contenant la valeur de la clé d’accès.
PERL permet d’avoir accès à l’ensemble des clés définies sur une table hachée en extension :
$toutes_cles = (keys %hash);
Il est possible de savoir si une clé d’une table hachée est déjà définie :
if(defined $hash{$val}) { ...
Nous aborderons plus précisément les structures conditionnelles dans la suite.
2.2.4 Quelques variables particulières
PERL définit les variables suivantes :
• @ARGV, tableau contenant les paramètres passés par la ligne de commande au
programme.
• $_, variable simple désignant l’entrée par défaut, nous y reviendrons par la suite.
• $!, variable simple renseignant l’erreur survenue
• STDIN, flux désignant l’entrée standard (i.e. le clavier).
• STDOUT, flux désignant la sortie standard (i.e. l’écran).
• STDERR, flux désignant la sortie d’erreur (i.e. l’écran).
2.3 Quelques opérations courantes
2.3.1 Opérations sur les chaînes de caractères
Syntaxe
$c1.$c2
$c1 eq $c2
$c1 ne $c2
$c1 ge $c2
$c1 gt $c2
$c1 le $c2
$c1 lt $c2
@tab = split /sep/, $c1
$c = join "sep", @tab
$c = substr($c1, dep, lg)
Description
concatène 2 chaînes
compare si 2 chaînes sont identiques
compare si 2 chaînes sont différentes
détermine si c1 >= c2
détermine si c1 > c2
détermine si c1 <= c2
détermine si c1 < c2
décompose la chaine c1 en morceau en fonction du
séparateur sep.
rassemble tous les éléments d’un tableau en les juxtaposant
les uns à la suite des autres séparés par le séparateur
mentionné.
extrait une sous-chaîne hors de c1, à partir de la position
dep, sur une longeur lg
4
2.3.2 Opérations sur les données numériques
Syntaxe
$n1 + $n2
$n1 - $n2
$n1 * $n2
$n1 / $n2
$n1++
++$n1
$n1---$n1
$n1 > $n2
$n1 < $n2
$n1 >= $n2
$n1 <= $n2
$n1 == $n2
$n1 != $n2
Description
Addition / soustraction / multiplication
Interprétation identique qu’en C
/
division.
Pré/post incrémentation. Identique qu’en C
Comparaison de deux nombres.
Interprétation identique qu’en C.
2.4 Les conditions
if ($I == $J) {
…
} elsif( $I == $K) {
...
} else {
...
}
if($c1 eq "oui") {
...
}
Observations :
• la syntaxe et l’interprétation sont proches de celle du C
• à l’inverse du langage C, les accolades sont obligatoires (même s’il n’y a qu’une
seule instruction).
2.5 Les boucles
for ($I=0;$I<5;++$I) {
...
}
while ($I <= 5) {
...
}
Observation :
• Le fonctionnement est identique qu’en C
2.6 Parcours d’un tableau ou d’une table
2.6.1 Parcours d’un tableau
for ($I=0; $I < (scalar @tab); ++$I) {
...
}
foreach $I (@tab) {
...
}
Dans la forme de gauche, la variable $I prend successivement tous les indices possibles du
tableau @tab.
Dans la forme de droite, la variable $I prend successivement toutes les valeurs contenues
dans le tableau @tab.
5
2.6.2 Parcours d’une table hachée
foreach $I (keys %hash) {
...
}
Dans cette forme, la variable $I prend successivement toutes les valeurs de clés définies
pour la table hachée %hash.
2.7 Quelques particularités
2.7.1 Les commentaires en PERL
Les commentaires en PERL sont précédés du symbole #.
# Voici un commentaire PERL
2.7.2 Interaction avec le clavier et l’écran
$info = <STDIN>;
print STDOUT $info;
print $info;
print STDERR "Erreur";
La première ligne permet de capturer des données au clavier et de les enregistrer dans la
variable $info.
Les deuxième et troisième lignes font la même chose : afficher à l’écran le contenu de la
variable $info. En effet, l’affichage se fait, par défaut, via STDOUT qui est, dès lors,
facultatif.
La dernière ligne permet d’envoyer un message d’erreur sur le flux STDERR. Par défaut,
celui-ci est connecté à l’écran.
2.7.3 Exécution d’une commande
my $cmd = "/usr/bin/who";
my $result = `$cmd`;
Dans cet extrait, la variable $cmd contient la chaîne /usr/bin/who (qui est le chemin vers
une commande du système). Ensuite, les apostrophes inverses sont utilisées pour exécuter
un programme externe. Le résultat que ce programme produit sur le STDOUT est récupéré
dans la variable $result.
2.8 Les fichiers
PERL permet une manipulation aisée des fichiers textes. La première chose à définir pour la
gestion des fichiers est le descripteur (ou handle). Il se déclare comme n’importe qu’elle
autre variable simple.
my $FHANDLE;
6
2.8.1 Ouverture du fichier
L’ouverture du fichier s’effectue par la commande open. PERL définit 3 modes d’ouverture :
ouverture en lecture, ouverture en écriture (ou écrasement) et ouverture en extension (ou
ajout).
open(FHANDLE, "< fichier.txt");
open(FHANDLE, "> fichier.txt");
open(FHANDLE, ">> fichier.txt");
La première ligne mentionne l’ouverture en lecture (c’est l’option par défaut). La seconde
ligne provoque la création ou l’écrasement du fichier tandis que la dernière ligne ouvre le
fichier en mode ajout.
2.8.2 Lecture
La lecture à partir du fichier s’effecture comme la lecture à partir du flux STDIN vu cidessus :
$ligne = <FHANDLE>
while($ligne) {
chomp($ligne);
...
print "la donnée lue est : $ligne\n";
$ligne = <FHANDLE>
}
Ce petit code montre comment il est possible de lire le contenu d’un fichier ligne par ligne.
La fonction chomp permet de supprimer les caractères de passage à la ligne.
PERL permet d’écrire cette lecture sous une forme raccourcie :
while(<FHANDLE>) {
chomp;
...
print "la donnée lue est : $_\n";
}
On remarque dans cette forme raccourcie la disparition de la variable $ligne. En fait, on
utilise implicitement la variable désignant l’entrée par défaut (voir section 2.2.4) qui contient
les données lues depuis le fichier.
2.8.3 Ecriture
L’écriture d’une ligne dans le fichier texte (pour autant que cela soit compatible avec son
mode d’ouverture) est très simple en PERL … en effet, on remarque encore la syntaxe
utilisée pour les flux :
print FHANDLE "Un petit texte\n";
Cette instruction provoque l’écriture du message dans le fichier texte.
7
2.8.4 Fermeture
La fermeture du fichier se fait via la fonction close.
close (FHANDLE);
2.9 Les expressions régulières
Une des plus grande force de PERL est probablement l’intégration des expressions
régulières.
On pourrait définir une expression régulière comme :
• une représentation, un masque que PERL va tenter d’appliquer sur un texte (un peu
comme le format de l’instruction scanf en C)
o Si le masque est compatible, c’est que le texte correspond à la description
attendue. Il est alors possible d’effectuer des opérations
o Si le masque est incompatible, c’est que le texte ne correspond pas à la
description fournie
Les expressions régulières sont très utiles lorsqu’il s’agit d’analyser un fichier texte (comme
les fichiers CSV par exemple). En PERL, les expressions régulières sont toujours encadrées
des symboles slash (/ expression_régulière /).
Les conventions suivantes sont d’applications. Voici un tout petit extrait de ces expressions
régulières :
Symbole
\s
\S
^
$
a
a+
a*
(ab)+
[^abc]
[a-z]
.
()
Description
un espace ou une tabulation
un caractère qui n’est ni un espace, ni une tabulation
premier élément de la ligne
dernier élément de la ligne
le caractère a
répétition (1-N) du caractère a
répétition (0-N) du caractère a
répétition (1-N) de la séquence ab
n’importe quel caractère qui n’est pas a, b ou c
n’importe quelle lettre minuscule
un caractère (n’importe lequel)
permet d’identifier l’élément concerné
Quelques exemples :
Le contenu
aaaaaaaa
correspond notamment à ces expressions
\S+
\S*
.*
a+
a*
abababaaaababab
^(ab)+a*(ab)+$
[ab]*
.*
2.9.1 Manipulation des expressions dans un programme
PERL permet d’intégrer les expressions régulières à de nombreux endroits. Ainsi, on peut
toujours vérifier si une donnée correspond à une expression donnée avec la comparaison sur
base d’expression écrite =~.
8
my $data = "aaaaaaaa";
if($data =~ /a*/) { print "répétition de a\n"; }
elsif ($data =~ /^(ab)+a*(ab)+$/) { print "séquence ab-a-ab\n"; }
else { print "séquence inconnue\n"; }
Une autre grande force de PERL est sa capacité d’identifier une expression régulière en
attribuant des variables locales à des morceaux de celle-ci. Par exemple :
my $data = "
Louis;SWINNEN;Av. Machin;2;4020;LIEGE";
if($data =~ /^\s+([^;]*);(\S*);(.*);(.);([0-9]+);([A-Z]*)$/) {
my $prenom = $1;
my $nom = $2;
my $adresse = $3;
my $bte = $4;
my $cp = $5;
my $loc = $6;
print "Prenom = $prenom, nom = $nom, localite = $loc\n";
} else {
print "Erreur d’analyse\n";
}
Comme nous pouvons le voir dans cet exemple, PERL attribue des variables locales $1 … $6
à tous les groupes de parenthèses. Ainsi l’exécution du code remplira les variables $prenom,
$nom, $adresse, $bte, $cp et $loc avec les valeurs qui sont contenues dans la zone de
texte.
2.9.2 Les expressions régulières dans l’analyse d’un fichier texte
Il est très courant d’analyser un fichier texte au moyen d’expressions régulières. Il s’agit là
d’un moyen puissant de gestion et manipulation des données. Ainsi dans les schémas que
nous avons vu précédemment, voici comment les expressions régulières vont venir s’insérer :
$ligne = <FHANDLE>
while($ligne) {
chomp($ligne);
if($ligne =~ / mon_expression_regulière_de_la_mort /) {
...
} elsif($ligne =~ /ma_deuxieme_expression/) {
...
} else {
print "Erreur d’analyse (ligne : $ligne)\n";
}
$ligne = <FHANDLE>
}
Dans cet exemple, nous supposons que nous avons besoin de deux expressions régulières
différentes pour analyser le fichier texte, ce nombre peut être très variable.
9
Voici la seconde forme (raccourcie) :
while(<FHANDLE>) {
chomp;
if(/mon_expression_regulière_de_la_mort /) {
...
} elsif(/ma_deuxieme_expression/) {
...
} else {
print "Erreur d’analyse (ligne : $_)\n";
}
}
10