Les bases de Perl

Ce document est largement inspiré du site anglophone www.comp.leeds.ac.uk/Perl/.

La programmation en Perl est souvent très utile pour traiter des textes sans effort. Cette feuille a pour but de donner certaines bases sur ce langage.


Un exemple basique

Nous donnons ci-dessous un exemple simple de programme en PERL:

#!/usr/local/bin/perl -w
#
# Program to do the obvious
#
print 'Hello world.';           # Print a message

Explications

Chaque programme Perl commence avec la première ligne

#!/usr/local/bin/perl

qui varie selon les systèmes. Cette ligne indique à la machine comment exécuter le fichier. Ici il dit de le lancer à travers perl. Les commentaires sont insérés dans un programme à l'aide du symbole #. Chaque instruction Perl doit être terminée par un point-virgule. La fonction print affiche des informations. Dans notre exemple, elle affiche la chaîne de caractères "Hello world".


Comment exécuter le programme ?

Tout d'abord, rendre votre fichier (<prog>) exécutable puis taper dans un shell, l'une des commandes suivantes

perl <prog>
./<prog>

Notez que pour obtenir des avertissements, il faut utiliser l'option -w et pour utiliser un "debugeur", il faut taper l'option -d.

perl -w <prog>
perl -d <prog>


Les variables scalaires

Les variables scalaires peuvent contenir soit des nombres soit des chaînes de caractères.

$priority = 9;
$priority = "high";
$priority = 'high';

Les noms des variables comprennent en général des lettres, nombres et underscore, mais ne commencent jamais par un nombre. Elles ont pour préfixe le caractère $. La variable $_ est spéciale.

Assignation

Les opérateurs arithmétiques fonctionnent comme en C.

$a = 1 + 2;
$a++;

Les opérateurs sur les Strings sont les suivants:

$a = $b . $c;   # Concaténation de $b et $c
$a = $b x $c;   # $b est répété $c fois
$a .= $b;       # On ajoute (append) $b à $a (String)

Affichage des variables

Le code suivant affiche "pommes et poires" :

$a = "pommes";
$b = "poires";
print "$a et $b\n";

Le code suivant affiche "4 pommes" :

$a = "pommes";
$b = 4;
print "$b $a\n";


Les variables de tableaux

Les tableaux sont des listes de scalaires (nombres ou chaînes de caractères). Les variables de tableaux ont le même format que les variables scalaires à part qu'elles sont préfixées par le symbole @.
L'instruction

@food  = ("apples", "pears", "eels");
@music = ("whistle", "flute");

assigne une liste de trois éléments dans une variable de tableau @food et une liste de deux éléments à une variable de tableau @music.

On peut accéder aux différents éléments de ce tableau à l'aide d'indices démarrant à 0. L'expression $food[2] retourne "eels". On notera que le symbole @ a été changé en $ car "eels" est un scalaire.

L'instruction

$food[3] = "orange";

permet d'assigner le scalaire "orange" à la position 3 du tableau @food; on pourrait également utiliser l'instruction

push(@food, "eggs");

afin d'ajouter le scalaire "orange" à la fin du tableau. La fonction push retourne la longueur de la nouvelle liste. L'indice du dernier élément de la liste peut se retrouver à l'aide de l'expression $#food.

Pour supprimer le dernier élément de la liste, on peut utiliser la fonction pop. Cette fonction retourne l'élément supprimé.

$element = pop(@food);     #  $element = "eels"

Affichage d'un tableau

Les instructions suivantes permettent d'afficher le tableau @food :

print "@food";


Les fichiers

Voici un programme Perl qui affiche le contenu du fichier "/etc/passwd" en sortie standard.

#!/usr/local/bin/perl -w
#

$file = "/etc/passwd";   # Nom du fichier
open(INFO, $file);       # ouverture du fichier
@lines = <INFO>;         # lecture du fichier dans un tableau
close(INFO);             # fermeture du fichier
print @lines;            # affichage du tableau

La fonction open ouvre le fichier en lecture. Le premier argument est le descripteur de fichier qui permet à Perl de se référer au fichier. Le deuxième argument indique le nom du fichier. La fonction close indique à Perl de fermer le descripteur de fichier. Dans le programme ci-dessus, l'information est lue dans un fichier. Le fichier a pour descripteur INFO, et pour lire dans celui-ci, Perl utilise des angles. Ainsi, l'instruction

@lines = <INFO>;

lit le fichier référencé par INFO et met son contenu dans le tableau @lines. Notez que l'expression <INFO> lit le fichier entièrement en une seule fois. Ceci est dû au fait que la lecture a pour contexte une variable de tableau. Si @lines est remplacé par un scalaire $lines alors seule la prochaine ligne est lue. Dans chacun des cas, chaque ligne est stockée complètement avec son caractère "newline" à la fin.

Le fichier peut être ouvert en écriture également ou en ajout. Pour cela, il faut préfixer le nom du fichier avec > si écriture et un >> si ajout :

open(INFO, $file);      # ouvert en lecture
open(INFO, ">$file");   # ouvert en écriture
open(INFO, ">>$file");  # ouvert en ajout
open(INFO, "<$file");   # ouvert en lecture

Pour écrire dans un fichier que vous avez déjà ouvert en écriture, vous pouvez utiliser l'instruction print avec un argument supplémentaire. Pour écrire une chaîne de caractères dans un fichier dont le descripteur de fichier est INFO, utiliser

print INFO "This line goes to the file.\n";

Pour ouvrir l'entrée standard et la sortie standard, vous pouvez utilisez respectivement :

open(INFO, '-');        # Ouverture de l'entrée standard
open(INFO, '>-');       # Ouverture de la sortie standard


Les structures de contrôle

foreach

Pour parcourir chaque élément d'un tableau, Perl utilise une structure foreach qui s'utilise comme suit :

foreach $element (@food)         # Visite chaque élément de @food et le place dans $element
{
        print "$element\n";      # affiche $element
}


Les tests

Voici quelques tests qui retournent vrai ou faux :

$a == $b                # indique si $a est numériquement égal à $b?
$a != $b                # indique si $a n'est pas égal numériquement à $b?
$a eq $b                # indique si la chaîne de caractères $a est égale à la chaîne de caractères $b?
$a ne $b                # indique si la chaîne de caractères $a n'est pas égale à la chaîne de caractères $b?

On peut aussi utiliser des opérateurs logiques :

($a && $b)              # $a ET $b
($a || $b)              # $a OU $b
!($a)                   # NON $a


Les boucles avec for et while

Le for et le while marchent comme en C comme montré dans les exemples ci-dessous :

for ($i = 0; $i < 10; $i++)
{
   print "$i\n";
}

$cnt = 0;
open(INFO,$file);
while($line = <INFO>){ #tant qu'on est pas arrivé à la fin du fichier
    #   print "$line";
    $cnt++;
}
print "Le fichier ci-dessus contient $cnt lignes\n";


Les accolades sont néanmoins obligatoires.

Les conditions

Le if marche comme en C comme le montre l'exemple suivant :
if ($a)
{
	print "La chaine n'est pas vide\n";
}
else
{
	print "La chaine est vide\n";
}
Les accolades sont néanmoins obligatoires.


Les expressions régulières

Les expressions régulières sont extrêmement utiles pour la manipulation de Strings. Une expression régulière est contenue entre des slashes (/). Le "matching" entre une chaine de caractère et cette expression régulière est réalisée à l'aide de l'opérateur =~. L'expression suivante est vrai si la chaîne de caractères "the" apparaît dans la variable $phrase.

$phrase =~ /the/

L'opérateur !~ est utilisé pour mettre en évidence la non-"matching":

$phrase !~ /the/

Le code suivant pourrait être une utilisation des expressions régulières:
if ($phrase =~ /under/)
{
	print "MATCH\n";
}

Le message s'afficherait si l'on avait :

$phrase = "Up and under";
$phrase = "Best winkles in Sunderland";

Mais ne s'afficherait pas si l'on avait :

$phrase = "Under the bridge";


Il est possible d'utiliser des variables pour stocker certaines parties des séquences reconnues par l'application d'une expression régulière à une séquence de caractères. Par exemple, le code suivant :

$sentence = "5\t13";

if($sentence =~ /(.*)\t(.*)/){
    $temp = $1 + $2;
    print "$temp\n";  
}

afficherait 18.

Pour plus de détails sur les expressions régulières, aller à l'adresse suivante.


Substitution

Perl permet de réaliser des subsitutions basées sur le matching des expressions régulières. Pour faire cela, il s'agit d'utiliser la fonction s avec l'opérateur =~. Pour remplacer l'occurrence de london par London dans la chaîne de caractères $phrase, on utilise l'expression :

$sentence =~ s/london/London/

Pour plus de détails sur les expressions régulières, aller à l'adresse suivante.


La fonction split

La fonction split découpe une chaine de caractères et la place dans un tableau. Elle utilise une expression régulière. Le code suivant

$info = "Dupond:Michel:Dentiste:12, rue de la Paix:Paris";
@personal = split(/:/, $info);

a le même effet que l'instruction

@personal = ("Dupond", "Michel", "Dentiste", "12, rue de la Paix","Paris");

Les tables associatives (ou tables de hachage)

Un tableau ordinaire nous permet d'accéder à un de ses éléments à l'aide d'un index (un entier). Le premier élément du tableau @food est $food[0], le deuxième est $food[1], etc. Mais, Perl autorise de créer des tableaux dont les éléments peuvent être accédés avec des String. Ce sont les tables associatives.

Pour définir une table associative, on peut utiliser la notation entre parenthèses standard, mais le nom de la table est préfixé par le signe %. Supposons que l'on veuille créer un tableau de personne avec leur âge, il ressemblerait à cela:

%ages = ("Paul", 39, "Jean", 34, "Marie", 27, "Léa", 21, "Max", 108);

Les noms de personnes  sont appelés  les clés de la table alors que les  âges sont les valeurs de la table.

Il est alors possible de trouver l'âge des personnes avec les expressions suivantes:
$ages{"Paul"};		# retourne 39
$ages{"Jean"};		# retourne 34
$ages{"Marie"};		# retourne 27
$ages{"Léa"};		# retourne 21
$ages{"Max"};		# retourne 108
Notez que le signe % a été changé en $ pour accéder à un élément particulier car chaque élément est un scalaire. La clé (ici les noms de personnes) est mise entre accolades.

Le code suivant liste toutes les clés de la table associative %ages :

foreach $key (keys %ages){
          print "$key\n";  
}

Le code suivant liste toutes les valeurs de la table associative %ages :

foreach $key (keys %ages){
          print "$ages{$key}\n";  
}

Le code suivant est équivalent au précédent :

foreach $val (values %ages){
          print "$val\n";  
}

Les fonctions

Comme tout bon langage de programmation, Perl autorise les utilisateurs à définir leurs propres fonctions. Une fonction personnelle a la forme

sub mysubroutine
{
print "Not a very interesting routine\n";
print "This does the same thing every time\n";
}

Une fonction personnelle est appelée avec le caractère & précédent le nom. Par exemple, la fonction mysubroutine serait appelé de la manière suivante

&mysubroutine;

ou

&mysubroutine();

Il est aussi possible d'utiliser des paramètres, de donner des valeurs de retour et d'utiliser des variables locales à la fonction(cf. ailleurs).