Perl

Samuel Chevalley
12 juin 2017

Un script Perl se présente sous la forme d’un fichier contenant une ou plusieurs commandes qui seront exécutées de manière séquentielle. Il pourra donc permettre d’automatiser une série d’opérations.
 

Tests et conditions en Perl

Les opérateurs de test


 

Test sur les objets

[ -d fichier ]
Vrai si le fichier existe et est un répertoire.
[ -e fichier ]
Vrai si le fichier existe.
[ -f fichier ]
Vrai si le fichier existe et est un fichier ordinaire.
[ -l fichier ]
Vrai si le fichier existe et est un lien symbolique.
[ -r fichier ]
Vrai si le fichier existe et est lisible.
[ -w fichier ]
Vrai si le fichier existe et est accessible en écriture.
[ -x fichier ]
Vrai si le fichier existe et est exécutable.
[ -s fichier ]
Vrai si le fichier existe et a une taille supérieure à zéro.
[ -z chaîne ]
Vrai si la longueur de la chaîne est nulle.
[ -s chaîne ]
Vrai si la longueur de la string n’est pas nulle.
[ -M fichier ]
Renvoie l’âge en jour du fichier (depuis le début de l’exécution du programme).

Faire un perldoc -f -X pour voir toutes les options.
 

Test sur les chaînes de caractères

[ n1 eq n2 ]
Vrai si n1 et n2 sont égaux.

[ n1 ne n2 ]
Vrai si n1 et n2 sont différents.

[ n1 lt n2 ]
Vrai si n1 est strictement inférieur à n2.

[ n1 le n2 ]
Vrai si n1 est inférieur ou égal à n2.

[ n1 gt n2 ]
Vrai si n1 est strictement supérieur à n2.

[ n1 ge n2 ]
Vrai si n1 est supérieur ou égal à n2.
 

Test sur les nombres

[ n1 == n2 ]
Vrai si n1 et n2 sont égaux.

[ n1!=n2 ]
Vrai si n1 et n2 sont différents.

[ n1 < n2 ]
Vrai si n1 est strictement inférieur à n2.

[ n1 <= n2 ]
Vrai si n1 est inférieur ou égal à n2.

[ n1 > n2 ]
Vrai si n1 est strictement supérieur à n2.

[ n1 >= n2 ]
Vrai si n1 est supérieur ou égal à n2.
 

Instruction If

L’instruction « if » permet d’effectuer des opérations si une condition est réalisée, elle possède 3 niveaux de complexité.

Niveau 1 :

if (CONDITION) {
     instruction(s)
}

Niveau 2 :

if (CONDITION) {
     instruction(s)
}
else { 
     instruction(s)
}

Niveau 3 :

if (CONDITION1) {
     instruction(s)
}
elsif (CONDITION2) {
     instruction(s)
}
elsif (CONDITION3) {
     instruction(s)
    ...
}

Exemple :

print "Aimez-vous les épinards ? (oui/non)\n"
my $rep = <>;
chomp $rep;
if  ($rep eq "oui") {
 print "C'est bien\n";
}
elsif ($rep eq "non") {
 print "Pas bien\n";
}
else {
  print "Vous devez répondre par oui ou pas non\n";
}

 

La boucle For

La boucle « for » s’articule autour de ce schéma :

for (initialisation de VAR; contrôle de VAR; modification de VAR) {
instruction(s)
}

Ce qui permet par exemple de coder un compte à rebours de 0 à 5:

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

Résultat :

0
1
2
3
4
5

 

La boucle Foreach

La boucle « foreach » s’articule autour de ce schéma :

foreach initialisation de VAR  (Liste ou tableau) {
instruction(s)
}

 
Exemple:

foreach my $i ("a","gogo","c","errr"){
print "$i\n";
}
 
my @table = (2,3,55,66);
foreach my $u (@table){
print "$u\n";
}

Résultat :

a
gogo
c
errr
2
3
55
66

 

La boucle While

La boucle « while » s’articule autour de ce schéma :

while (CONDITION ) {
instruction(s)
}

CONDITION est une condition de continuation de la boucle et tant que cette condition est vraie, la boucle continue.

Généralement, il faut définir les variables de CONDITION avant le while, sinon la condition n’est pas vérifiable (vu qu’elle n’est pas définie).

Exemple :

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

Résultat :

0
1
2
3
4
5

Pour la syntaxe des opérateurs de test et de comparaison numérique dans les crochets (exemple avec -le), reportez-vous plus bas.

 

La boucle Until

La boucle « until » (même synthaxe que la boucle « while ») s’arrête quand CONDITION est vraie, alors que la boucle « while » continue tant que CONDITION est vraie.
 

Quelques exemples :

Script qui écrit dans un fichier la table de multiplication jusqu’à 100 d’un nombre renseigné :

#!/usr/bin/perl
use strict;
use warnings;
 
print "Entrez un nombre afin de connaitre sa tabe de multiplication jusqu'à 100\n";
my $nombre = <>;
chomp $nombre;
 
my $fichier_dst = "/home/schevalley/tmp/table.txt";
print "Le fichier de destination utilisé est $fichier_dst\n";
 
open (my $fh_dst, ">", $fichier_dst) or die "Impossible de créer le fichier";
 
for (my $compt = 1; $compt <= 100; $compt = $compt + 1) {
        my $multi = $compt * $nombre;
        print $fh_dst "$compt x $nombre = $multi\n";
}
 
close $fh_dst;

 
Résultat avec 567 en input :

table.txt
1 x 567 = 567
2 x 567 = 1134
3 x 567 = 1701
4 x 567 = 2268
5 x 567 = 2835
6 x 567 = 3402
7 x 567 = 3969
..
..

  
Jeu du plus ou du moins :

#!/usr/bin/perl
use strict;
use warnings;
 
my $mystere = int(rand 101);
my $choice = -1;
my $compt = 1;
 
while ($choice != $mystere){
        print "Devinez le nombre mystere entre 1 et 100 ?\n";
        $choice = <>;
        chomp $choice;
print "$compt\n";
        if ($choice > $mystere){
                print "C'est moins\n";
                $compt = $compt + 1;
        }
        elsif ($choice < $mystere) {
                print "C'est plus\n";
                $compt = $compt + 1;
        }
        else {
        print "BRAVO le nombre mystere est bien $mystere, vous avez trouvé en $compt essais\n";
        }
}

 

Les regex

Les basiques

Symbole
Correspondance
Exemple
/
Caractère d’échappement
[\.] contient un « . »
^
Début de ligne
^b$ contient uniquement b
.
N’importe quel caractère
^.$ contient un seul caractère
$
Fin de ligne
er$ finit par « er »
|
Alternative
^(a|A) commence par a ou A
( )
Groupement
^((a)|(er)) commence par a ou er
Intervalle de caractères
^[a-d] commence par a,b,c ou d
[ ]
Ensemble de caractères
[0-9] contient un chiffre
[^]
Tout sauf un ensemble de caractères
^[^a] ne commence pas par a
+
1 fois ou plus
^(a)+ commence par un ou plusieurs a
?
0 ou 1 fois
^(a)? commence ou non par un a
*
0 fois ou plus
^(a)* peut ou non commencer par a
{x}
x fois exactement
a{2} deux fois « a »
{x,}
x fois au moins
a{2,} deux fois « a » au moins
{x, y}
x fois minimum, y maximum
a{2,4} deux, trois ou quatre fois « a »

 

Les équivalences

Alias
Correspondance
Equivalence
\n
Caractère de nouvelle ligne
\r
Caractère de retour à la ligne
\t
Caractère de tabulation
\s
Caractère d’espacement (espace, tabulation, saut de page, etc)
[\f\n\r\t\v]
\S
Tout ce qui n’est pas un espacement
[^\f\n\r\t\v]
\d
Un chiffre
[0-9]
\D
Tout sauf un chiffre
[^0-9]
\w
Un caractère alphanumérique
[a-zA-Z0-9_]
\W
Tout sauf un caractère alphanumérique
[^a-zA-Z0-9_]

 

Les fonctions utiles

Join

La fonction join prend en paramètre un scalaire et une liste ; elle renvoie une chaîne de caractères comportant les éléments de la liste, concaténés et séparés par ce premier paramètre scalaire.
scalaire = join( séparateur, liste );

my $a = join("-", @b);

 

Split

La fonction split prend en paramètres un séparateur et une chaîne de caractères ; elle renvoie la liste des éléments de la chaîne de caractères délimités par le séparateur.
liste = split(/séparateur/, chaîne );

my @a = split(/;/, $list_services);

 

Grep

La fonction grep prend en paramètres un critère de sélection et une liste ; elle renvoie la liste des éléments correspondant au critère.
liste2 = grep(/sélection/, liste1);

my @b = grep(/enabled/, @a);

 

Sort

La fonction sort prend en paramètres un bloc d’instructions optionnel et une liste ; elle renvoie une liste triée conformément au critère de tri constitué par le bloc d’instructions.
liste2 = sort( liste1 );
liste2 = sort( { comparaison } liste1 );

my @c = sort(@a);

 

Map

La fonction map prend en paramètres un bloc d’instructions et une liste ; elle applique le bloc à chacun des éléments de la liste (modification possible de la liste) et renvoie la liste constituée des valeurs successives de l’expression évaluée.
liste2 = map( { expression } liste1 );

my @d = map({ $_=~ m/(\S+)/; $1 } @b);