Perl est un langage interprété très utilisé par les WebMasters dans la programmation des scripts Web (CGI). Sa syntaxe ressemble fort à celle des shells Unix (sh, ash, bash). Perl est un langage très puissant dans la manipulation des textes, sa grande force est le traitement des chaines de caractères.

PERL signifie: Practical Extraction and Report Language.

Ce langage a été développé par Larry Wall comme système de report de bug.
Il fonctionne sur beaucoup de machine et système d'exploitation: PC, Mac, Amiga, UNIX, OS/2, VMS, DOS, Windows.

PERL est distribué selon les termes de la licence GNU. Son interpréteur et un grand nombre de bibliothèques sont disponibles gratuitement sur Internet.

• 1 - Votre premier programme.
• 2 - Lancer et éxécuter le programme.
• 3 - Les variables scalaires.
• 4 - Les variables tableaux.
• 5 - Les opérations sur les nombres.
• 6 - Les opérations sur les chaines.
• 7 - Les assignements.
• 8 - Les comparaisons.
• 9 - Les opérations et assignements sur les tableaux.
• 10 - Les fichiers.
• 11 - Les instructions conditionnelles.
• 12 - Exemple complet: un compteur.
• 13 - les boucles.
• 14 - les fonctions.
• 15 - les expressions régulières.

#!/usr/local/bin/perl
#
# ceci est un commentaire
#
print 'Bonjour le monde.';  # Imprime le message
    

#!/usr/local/bin/perl
    

Cette ligne indique au shell que nous sommes en présence d'un fichier de type PERL, elle donne aussi la localisation de l'interpréteur perl. Elle peut varier d'un système à un autre. Elle n'a pas de signification particulière sous Dos ou Windows, sauf offrir une signature pour la reconnaissance du type de fichier et peut s'écrire simplement:

#! perl
    

Le caractère # indique un commentaire, tout le texte qui le suit jusqu'à la fin de ligne est ignoré par le compilateur (à l'exception de la première ligne du programme). Pour insérer plusieurs lignes de commentaires, il faut mettre un # à chaque début de ligne.

print 'Bonjour le monde.';
    

Cette ligne utilise la commande print pour demander à l'interpréteur d'afficher le texte Bonjour le monde., toutes les commandes terminent par un ;

Nous supposons que l'interpréteur PERL est correctement installé sur votre machine, et que son chemin d'accès a été ajouté dans la liste des "paths" de votre ordinateur.

Les lignes du petit programme ci-dessus peuvent être saisies avec n'importe quel éditeur de texte. Nous supposerons qu'il a été sauvé sous le nom de essai.pl

Pour lancer son éxécution il suffit d'écrire la ligne de commande suivante:

perl essai.pl
    

Vous devez voir apparaitre le message bonjour le monde à la ligne suivante. Si rien ne se passe, il est possible d'utiliser l'option -w pour demander l'affichage des "Warnings".

perl -w essai.pl
    

Les variables scalaires sont les plus plus utilisées en PERL. Elles ont le grand avantage de pouvoir interchanger les nombres et les chaines.
Vous pouvez écrire:

$var = 12;          # un nombre entier
    

$var = 'Bonjour';   # une chaine de caractères
    

Vous pouvez aussi affecter des valeurs numériques comme des chaines de caractères.

$var = '12';        # un nombre en tant que chaine de caractères
    

Un nom de variable scalaire commence toujours par le caractère $ et peut contenir des lettres, des chiffres, et le caractère _ (underscore). En PERL tous les identificateurs sont sensibles à la "casse", ainsi: $Var ne représente pas la même variable que $var. Il existe une variable spéciale $_ nous en reparlerons plus loin.

Les chaines de caractères constantes peuvent aussi être assignées en "bloc".

$TexteBloc = <<_FIN_;
Ceci est un bloc de texte assigné à la variable TexteBloc.
Il peut être imprimé tel-quel.
_FIN_

print "$TexteBloc\n";
    

On distingue deux types de tableau: les tableaux de valeurs, et les tableaux associatifs.

Ils sont déclarés de la même façon que les variables scalaires, mais à la place du $ il faut mettre un @

@tableau = ("Objet1", "Objet2", "Objet3");
    

Cela rempli la variable avec trois éléments accessibles par un adressage indicé, le premier élément du tableau à l'indice 0 (comme en C).

le premier élément du tableau:   $tableau[0]
le second élément du tableau:    $tableau[1]
le troisième élément du tableau: $tableau[2]
    

Ils sont déclarés de la même façon que ci-dessus, mais cette fois, il faut précéder leur déclaration d'un %.
Ces tableaux sont accessibles par une chaine de caractères qui constitue l'index. Ils doivent toujours contenir un nombre pair de valeurs.

%ages = ("Alienor",11,"Ulrich",17,"Cynthia",20,"Aristote",14);
    

$age = $ages ("Ulrich");
    

Perl utilise les mêmes opérateurs et les mêmes priorités arithmétiques qu'en C.

$a = (1 + 2) * 3 - 4; # retourne 5 dans $a
$a = 7 / 8;           # Divise 7 par 8 et met 0.875 dans $a
$a = 9 ** 10;         # 9 à la puissance 10
$a = 5 % 2;           # le reste de 5 divisé par 2
++$a;                 # retourne $a augmenté de 1
$a++;                 # retourne $a avant de l'augmenter de 1
--$a;                 # retourne $a diminué de 1
$a--;                 # retourne $a avant de le diminuer de 1
    

$a = $b . $c;   # concatène $b et $c
$a = $b x $c;   # répète $b, $c fois    
    

$a = $b;        # Assigne $b à $a
$a += $b;       # ajoute $b à $a, met le résultat dans $a
$a -= $b;       # soustrait $b de $a, met le résultat dans $a
$a .= $b;       # ajoute la chaine $b à la fin de $a
    

$a == $b        # Retourne vrai si $a est égal à $b
$a != $b        # Retourne vrai si $a est différent de $b
$a > $b         # Retourne vrai si $a est supérieur à $b
$a < $b         # Retourne vrai si $a est inférieur à $b
$a >= $b        # Retourne vrai si $a est supérieur ou égal à $b
$a <= $b        # Retourne vrai si $a est inférieur ou égal à $b
    

$a eq $b        # Retourne vrai si $a est identique à $b
$a ne $b        # Retourne vrai si $a est différent de $b
$a gt $b        # Retourne vrai si $a est supérieur à $b
$a lt $b        # Retourne vrai si $a est inférieur à $b
$a ge $b        # Retourne vrai si $a est supérieur ou égal à $b
$a le $b        # Retourne vrai si $a est inférieur ou égal à $b
    

- Pour connaitre le nombre d'éléments constitutifs d'un tableau, il suffit d'écrire:

$NbElem = @tableau;
    

- Pour obtenir l'indice du dernier élément d'un tableau, il suffit d'écrire:

$LastElem = $#tableau;
    

Un des rares cas où le # ne représente pas le début d'un commentaire.

- Pour mettre dans une variable toute la liste des éléments du tableau séparés par une virgule, il suffit d'écrire:

$ListeElem = "@tableau";
    

- Pour ajouter à la fin d'un tableau, un élément, une liste d'éléments, ou un autre tableau, il faut utiliser la commande push. Cette commande retourne la nouvelle valeur de la longueur du tableau.

push (@tableau, "Objet4");
$lng = push (@tableau, @tableau1);
    

- Pour lire et/ou retirer le dernier élément d'un tableau, il faut utiliser la commande pop.

$DernierObjet = pop (@tableau);
    

- Pour trier les éléments d'un tableau, il faut utiliser la commande sort.

$TableauTrie = sort (@tableau);
    

Il y a plusieurs façons d'ouvrir un fichier:

open (FH, "NomDuFichier");   # Ouverture en lecture
open (FH, "<NomDuFichier");  # Ouverture en lecture aussi
open (FH, ">NomDuFichier");  # Création ou écrasement d'un fichier
open (FH, ">>NomDuFichier"); # Ajout à la fin du fichier
    

Ecrire dans le fichier:

print FH "Le texte à écrire dans le fichier";
    

Lire dans le fichier:

@lignes = <FH>;
    

On affecte à la variable tableau @lignes le contenu du fichier.

Pour fermer le fichier après utilisation:

close (FH);                  # fermeture du fichier
    

Il est possible d'effectuer des actions conditionnées à l'aide de l'instruction if.
La syntaxe générale est:

if (condition1)
{ 
  # Actions à exécuter si la condition 1 est remplie.
}
elseif (condition2)
{
  # Actions à exécuter si la condition 2 est remplie.
}
else
{
  # Actions à exécuter si aucune des conditions n'est remplie.
}
    

Utilisation d'opérateurs booléens:

    && utilisé en tant qu'opérateur AND
    || utilisé en tant qu'opérateur OR
    !  utilisé en tant qu'opérateur NOT
    

Maintenant nous avons suffisamment d'éléments pour écrire un programme plus complexe.

#! perl
# Ce programme doit incrémenter un compteur

# initialisation des variables
$file = 'data.txt';               # Le nom du fichier compteur
$cpt  = '0';                      # le compteur lui-même

if (open (FH, $file))             # Lecture du fichier compteur
{
  $cpt = <FH>; 
  close FH;
}

$cpt += 1;                        # augmente le compteur de 1

open (FH, ">$file");              # Ecriture du fichier compteur
  print FH "$cpt";
close FH;
      
print "Valeur du compteur: $cpt"; # affiche le compteur
    

A chaque fois que ce programme est lancé, il lit le fichier "data.txt" qui contient la valeur du compteur. Celui-ci est augmenté de 1, puis le fichier est écrasé et réécrit avec la nouvelle valeur du compteur. Ensuite la valeur du compteur est affichée.

Remarque: dans l'instruction print ci-dessus, nous avons passé en paramètre une chaine entourée de ", ceci permet d'ordonner à l'interpréteur d'analyser la chaine, et de remplacer la variable $cpt par sa valeur avant de l'envoyer à l'écran.
Si nous avions utilisé des ', la chaine aurait été intégralement transmise vers l'écran.

Comme dans les autres langages il y a plusieurs types de boucles.

Elle permet de parcourir tous les éléments d'un tableau. Sa syntaxe est:

foreach $Objet (@tableau)
{
  # instructions liées au traitement de $Objet
}
    

L'exemple suivant nous montre comment imprimer toutes les lignes d'un texte.

foreach $Ligne (@lignes)
{
  print "$Ligne\n";
}
    

Remarque: nous utilisons \n pour indiquer qu'il faut passer à la ligne à la fin de chaque ligne imprimée.

La syntaxe de cette instruction est identique à celle du C:

for (initialisation; test; incrémentation)
{
  # liste de commandes à effectuer
}
    

Exemple: imprime les valeurs de 0 à 4

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

Boucle tant que la condition est vraie. Comme pour la boucle for il se peut que la boucle ne soit jamais exécutée.

$i = 0;
while ($i < 5)
{
  print "$i\n";
  $i++;
}
    

Il existe un autre type de boucle, qui sera toujours exécutée au moins une fois.
La boucle do until:

$i = 0;
do {
  print "$i\n";
  $i++;
} until ($i > 4);
    

Les fonctions ou sous-routines, sont des blocs de code qui peuvent être appelés de tout autre endroit du programme. C'est une façon d'écrire un bloc de code qui doit souvent être exécuté. Elles peuvent être placées n'importe où dans le programme, généralement, pour des raisons de lisibilité on les place soit au début ou soit à la fin du programme.

sub MaSousRoutine
{
  # lignes de code à exécuter
}
    

Pour appeler une sous routine, il faut placer le caractère & devant son nom.

&MaSousRoutine;
    

Les paramètres sont passés en tant qu'arguments de l'appel de la fonction, ils sont séparés par des virgules, le tout placé entre parenthèses.
Les arguments sont récupérés dans la sous routine via une variable prédéfinie @_, chaque élément étant accessible par son index (le premier à l'index 0).

sub Affichage
{
  print "Premier paramètre $_[0]\n";
  print "Second paramètre $_[1]\n";
}

&Affichage ("Param 1", "Param 2");
    

En perl la valeur de retour d'une sous-routine correspond toujours au résultat de la dernière évaluation. La sous-routine ci-dessus retourne la valeur 1, parce que la fonction print retourne la valeur 1, correspondant à une exécution réussie.

sub Maximum
{
  if ($_[0] > $_[1])
  { 
    $_[0];
  }
  else
  {
    $_[1];
  }
}

print "Le maximum de 12 et 18 est: ".&Maximum (12, 18)."\n";
    

La variable locale @_ est une variable locale, ainsi que les variables qui en dépendent directement $_[0] etc...
D'autres variables peuvent être déclarées locales explicitement par la commande local

sub Maximum
{
  local ($a, $b);            # déclaration des variables locales
  ($a, $b) = ($_[0], $_[1]); # assignement des paramètres
  # puis calcul
  if ($a > $b) { $a; } else { $b; }
}
    

sub Maximum
{
  # déclaration des variables locales et assignement des paramètres
  local ($a, $b) = ($_[0], $_[1]); 
  # puis calcul
  if ($a > $b) { $a; } else { $b; }
}
    

Le langage PERL possède une grande puissance de traitement des expressions régulières. Elles représentent un masque de recherche de caractères dans une chaine de caractères. Elles sont toujours placées entre deux caractères /.

Exemple:

/abc/     # recherche les caractères a b c d dans une ligne
    

Caractère  Description                          Inverse
\d         chiffres (0-9)                       \D 
\w         caractères (0-9,a-z,A-Z,_)           \W 
\s         espaces ou assimilés ( ,\r,\t,\n)    \S 
\b         La frontière des mots, hors []       \B
\n         Une nouvelle ligne
\t         Une tabulation
.          tout caractère sauf une nouvelle ligne
+          matches one or more when combined with above    
^          Le début d'une ligne ou d'une chaine
$          La fin d'une ligne ou d'une chaine
*          Zero ou plusieurs fois le dernier caractère
+          Une ou plusieurs fois le dernier caractère
?          Zero ou une fois le dernier caractère
    

Les caractères $, |, [, ), \, / sont réservés, si on veut les représenter tel quels, il faut les faire précéder d'un caractère \.

Les crochets indiquent une énumération de caractères. Le caractère - indique tout ce qu'il y a entre les deux caractères. Le caractère ^ au début de la chaine entre crochet indique une négation.

Exemple:

/[abcd]/ # tout ce qui coïncide avec a ou b ou c ou d
/[^abc]/ # tout ce qui est différent de a ou b ou c
/[a-z]/  # les caractères minuscules
/[^a-z]/ # tout ce qui n'est pas une minuscule
/[a-z]+/ # une chaine de caractères non nulle en minuscule     
    

/a.b/    # a suivi d'un caractère suivi de b
         # coïncide avec axb, mais pas avec ab ou axyzb
/.*/     # tout sauf une nouvelle ligne
/^abc/   # abc au début d'une ligne
/abc$/   # abc à la fin d'une ligne
/abx*/   # ab suivi de zero ou plusieurs caractères x
         # coïncide avec ab abx abxx abxxxxx
/^$/     # une ligne vide
/\/\s*0/ # / suivi de zero ou plusieurs espaces suivi de 0
         # représente une division par 0
    

Une barre verticale | représente un "ou". Les parenthèses () permettent de faire des regroupements.

/Ulrich|Aliénor/ # Ulrich ou Aliénor
/(ab|de)xx/      # abxx ou dexx