www.infkoffler.com - Site de cours d'informatique

Accueil

Java Standard Edition

Java EE 5

Visual Basic .Net 2005

Cours Javascript - DOM - DHTML

Nouveautés sur le site

Contacts

Accueil > Perl > Perl

____________________________________________________________________________________________________

Connexion

Le langage PERL

Le langage PERL
05/03/2008

I)Introduction

PERL signifie Practical Extraction and Report Language. Il est paru pour la première fois en 1987. Il a été créé par Larry Wall. Perl 5 est paru en octobre 1994. Perl est un interpréteur. C’est un langage accessible facilement sous linux.

Extrait de Wikipédia : « Perl est né du besoin de disposer d'un langage optimisé pour l'extraction d'informations de fichiers textes et la génération de rapports. Avant la naissance de Perl, les traitements sur le texte devaient être faits au moyen de scripts shell, en utilisant les programmes sed, awk, grep, cut, test et expr. Beaucoup de limites apparaissaient quand on utilisait cette programmation : format des (…)»

Perl est un langage qui se veut pratique(comme son nom l’indique d’ailleurs), il a été conçu avec cette philosophie.
Perl, comme son nom l’indique aussi, a été construit initialement avec l’objectif de faciliter l’extraction de données et la génération de rapport. Comme pour toutes choses, avoir un objectif permet d’obtenir un bon résultat, car il est difficile d’atteindre des objectifs qu’on n’avait pas ! Quand on sait ce qu’on veut, on sait où on va, et on va répondre aux besoins de l’objectif. Sans objectif, il est difficile de penser aux besoins, donc difficile d’y apporter des réponses !

Autre extrait de Wikipedia :
« Perl regroupe et emprunte sa syntaxe concrète à tous ces mini langages, dont le shell, en ajoutant une partie de la syntaxe du C et les fonctions des bibliothèques système en C. »

II) Premier programme

Cygwin : une émulation d’une machine Unix et un ensemble de logiciels notamment Perl, Java, C, Python, C++.

Tout ce qui suit a été essayé avec CygWin uniquement. Perl est à la version 5.8.8 dans Cygwin( Perl –v), qui est une version récente et la plus répandue dans les distributions les plus récentes.

II.a) Premier programme

Exemple de programme qui affiche à l’écran « Hello world ! » :

«
#!/usr/bin/perl -w

&MaProcedure();

sub MaProcedure
{
print "Hello world!";
}
»

Le « &Main() ; » est indispensable, sinon ça ne fait rien, bien sûr. Le & n’est plus indispensable depuis Perl 5.

II.b) Exécution d’un programme Perl

Soit depuis la ligne de commande, on tape :

perl monProg.pl

ou , deuxième solution, ajouter dans le script, en haut :

#!/usr/bin/env perl (env.exe est un utilitaire unix qui doit permettre de localiser la commande ‘perl’).
ou #!/usr/bin/perl , on donne ici directement le nom de l’exécutable à utiliser pour exécuter le script.

III) Syntaxe de PERL

III.a) Généralités sur la syntaxe

Comme en C, les lignes se terminent par un « ; » .

La concaténation : le point « . » .

III.a.1) Guillemets simples et guillemets doubles

Différence entre guillemets simples et guillemets doubles, comme en PHP :
«
$maVar = "jean" ;
print "La personne est : $maVar\n" ; #syntaxe souple et très pratique, car lisible. Va remplacer le contenu de #maVar et va passer à la ligne print 'La personne est : $maVar\n'; #ne va pas interpréter du tout. Va afficher "La personne est : $maVar\n"
»

La syntaxe double guillemets(« ») va interpréter le contenu de la chaîne, et va remplacer les variables trouvées par leur contenu. C’est une syntaxe à la PHP, qui est souple et lisible, car on ne sépare pas la chaîne affichée des variables. Ceci a pour effet que le programme est plus lisible, car on n’a plus à imaginer mentalement le résultat produit pour connaître l’affichage que ça fera. Cela s’appelle une interpolation des variables. La quote simple(‘’) n’interprète pas le contenu de la chaîne. A noter que le « \n » n’est pas interprété non plus.

III.b) Les commentaires

Les commentaires : débutent par #, et se terminent à la ligne.

III.c) Le mot-clé my – variables locales et variables globales

Le mot-clé my définit des variables locales au bloc courant ({}). C’est donc l’équivalent d’une déclaration de variable locale en langage C.
«
my $maVar = "jean" ;
print "La variable locale est : $maVar\n" ;
»

Sans le my, la variable est globale, accessible dans tout le programme.
$varGlob = "var glob";
print "La variable globale est : $varGlob\n" ;

III.d) Les variables en PERL

On remarque que chaque variable est précédée du $,@ ou %, qui sont ce que j’appelle des indicateurs de variable. C’est comme en PHP, qui lui en a un seul, le $. Cela permet d’avoir un langage où chaque variable est demandée explicitement, ce qui rend le code plus sûr. Et ici, de plus, on précise explicitement le type de la variable, ce qui rend encore plus sûr le code, et moins ambiguë.

III.e) Les tableaux

Il y a toujours un @ avant le nom du tableau. Par contre, quand on parle d’un élément d’un tableau, on utilise le $, dans le cas, bien sûr, où l’élément du tableau est un scalaire.

Exemples :
@personnes = ( 'jean', 'paul', 'pierre', 'patrick', 'philippe') ;
print $personnes[2] ; # Cela affiche « pierre ».
print @personnes; # cela affiche jeanpaulpierrepatrickphilippe

My $maVar = @personnes # Met la taille du tableau(2 ici) dans $maVar Les indices commencent à l’indice 0, comme en langage C.

@monTableau placé à un emplacement où on attend un scalaire, va donner le nombre d’éléments du tableau.

III.f) Les types de données

Il existe trois types : les scalaires, les tableaux et les tables de hachage.

Les scalaires : cela peut être des entiers, des chaînes de caractères, des nombres à virgule flottante, …
Les scalaires sont précédés du caractère $.

Les tables de hachage ou hash: c’est un ensemble de paires clé/valeur.
On précède de % le nom de la variable.

my %dico = (
humain => "être vivant bipède", #aurait marché en mettant des guillements ("humain")
girafe => "animal de grande taille"
);

Comme pour les tableaux, on utilise $ pour parler d’un élément de la table de hachage.
print $dico{"girafe"}; #affiche "animal de grande taille"

Pas de booléens(comme en C) : on se sert des entiers. 0 est considéré comme faux, 1 comme vrai.

III.g) Le If

Syntaxe :
if (expression) {
(…)
}
else {
(…)
}

Ou encore
if (expression) {
(…)
}
elsif (expression) {
(…)
}
elsif (expression) {
(…)
}

Remarque :
On peut écrire aussi :
print ‘Bonjour’ if ($salut eq ‘oui’) ;
Ceci va afficher « Bonjour » si la variable salut = « oui ».
C’est une autre syntaxe, on écrit la condition après, mais cela revient exactement au même. Dans cette syntaxe, on perd la certitude que quand on écrit une action, elle est exécutée sans condition. Ceci nuit donc à la lisibilité du programme.

III.h) Comparaisons – comparaisons de chaînes

Opérateurs de comparaisons en général : comme en langage C :
!=not, || = ou, &&=et, = = correspond à égal
Depuis Perl 5, on peut utiliser not, or, and.

Comparaison de chaînes : utiliser eq(égal), ne( différent), gt( supérieur à), ge(supérieur ou égal), lt(inférieur à), le(inférieur ou égal).

III.i)Conversions automatiques

«
my $strVar = '126';
print $strVar - 32;
”

Affiche bien 94. La string a été convertie en nombre, car d’après le contexte, Perl pouvait devinait qu’il fallait convertir la string en nombre. Car on ne peut soustraire un nombre qu’à un nombre. Cette conversion automatique va dans l’esprit de perl, cela simplifie la syntaxe, l’allège, cela nous enlève des contraintes.

III.j)Opérateurs:

Modulo : %
Exemple : 19 % 4

III.k)Les boucles

Le for: comme en langage C.
Exemple :
for ( $i=0; $i<length($maChaine);$i++)
{

}
« last ; » est comme le « break ; » en C, il permet de sortir immédiatement de la boucle( par seulement pour les boucles for).

III.l)Les fonctions prédéfinies

III.l.1) exit

exit : arrête le programme
Exemple : exit ;

III.l.2) die

Die : arrête le programme et en affichant un message d’erreur Exemple : die ‘Une erreur s’est produite’ ;

III.m)Arguments de la ligne de commande

Tous les arguments sont dans un tableau particulier, @ARGV.
Le premier argument est $ARGV[0] .

III.n)Procédures et fonctions

Appel d’une procédure: le & n’est plus indispensable depuis Perl 5.
Paramètres : ils sont contenus dans un tableau spécial : @_ , qui est bien entendu local à la procédure.

Pour faire une procédure à trois paramètres scalaires, on peut faire :
sub MaProcedure( ), sans préciser les paramètres ou bien sub MaProcedure($$$), les deux fonctionnent.
On remarque donc qu’on peut ne pas préciser les paramètres car le nombre de paramètres n’est pas défini pour une procédure.

Pour récupérer les paramètres dans la procédure :

my ( $param1, $param2, $param3) = @_ ;
pour avoir les 3 premiers paramètres.

Ou encore :
my ($param1) = @_ ;
qui équivaut à $param1 = $_[0] ;

Le nombre de paramètre est laissé libre.
Pour connaître le nombre de paramètres :
$nb = @_ ; ou alors $nb = scalar(@_) ;

Les paramètres sont passés par valeur en Perl, par défaut. C'est-à-dire qu’une variable que vous passez ne peut pas être modifiée dans la procédure( en tout cas, la modification ne sera pas visible au programme appelant, car la valeur ne sera pas modifiée dans la vraie variable). La seule solution est de passer le paramètre par référence, par exemple :

my $maVar;
MaProcedure(\$maVar);
print "APRES APPEL, maVar = $maVar\n"; #affiche 29
exit(0);

#Cette procedure met 29 dans la variable maVar
sub MaProcedure(\$) #On n’est pas oblige de préciser \$
{
my($ref_maVar)= @_;
${$ref_maVar} = 29;
}

III.o)Les fonctions

Une fonction est une procédure(sub) qui retourne une valeur.
Exemple :

sub MaFonct
{
my $retour = 5;
return($retour);

}

III.p)Les références en PERL

Les références existent en PERL, et sont l’équivalent des pointeurs en C.
Les références sont indispensables, en PERL, pour passer en paramètres des tableaux ou des hashs. Si on utilise la manière my ( $param1, $param2, $param3) = @_ ; , le passage de paramètres ne se passe pas correctement pour passer des tableaux ou des hashs. Il faut donc les passer par référence.

Comment obtenir l’adresse d’une variable : il suffit de mettre le caractère \ devant( comme le & du langage C).
Exemple :
my $ref_monTab = \@monTab ;
my $ref_monHash = \%monHash;

Remarque: on peut afficher les references:
print $ref_MonTab ;
On a alors la valeur de l’adresse sur 32 bits en hexa qui est affichée. Par exemple 0x100110b0. On rappelle que 32 bits permettent d’adresser 4 Go.

III.p.1) Les références anonymes

Les references anonymes: on crée un tableau ou un hash en mémoire, mais on garde uniquement sa référence, on n’a pas de variable associée à ce tableau ou hash.

Pour ce faire, on change un peu la syntaxe de déclaration de tableau ou de hash : on remplace le ( ) du tableau par des crochets[ ]. Et on remplace les ( ) de déclaration du hash par des accolades { }.
Par exemple :
my $ref_monTabAnn = [ 0, 1, 2, 3 ] ;
Ici on crée un tableau de 4 éléments en mémoire, et on met sa référence dans la variable $ref_monTabAnn.
On remarque les crochets au lieu des parenthèses.

my $ref_monHashAnn = { « cle1 » => « valeur1 », « cle2 » => « valeur2 », « cle3 » => « valeur3 » } ;

Ici on crée un hash en mémoire, qu’on décrit, et on met sa référence dans la variable $monHashAnn.
On remarque les accolades au lieu des parenthèses.

Il y a donc une syntaxe explicite( les crochets et les accolades) afin que le programmeur demande expressément ce qu’il veut, cela permet d’ajouter de la sûreté à cette requête qui est particulière. Mais cela permet surtout de différencier ce qu’on veut. En effet, en écrivant, pour le tableau, avec des crochets, on aurait pu vouloir effectuer une déclaration classique de variable tableau.

Remarque :
On peut faire aussi
my $ref_monHashAnn = { } ; #on crée une référence anonyme
$ref_monHashAnn->{‘cle1’} = « valeur1 » ;
$ref_monHashAnn->{‘cle2’} = « valeur2 » ;
$ref_monHashAnn->{‘cle3’} = « valeur3 » ;
On crée ici un objet anonyme hash en mémoire. On l’initialise après. Mais cela revient au même que la première façon de faire.

III.p.2) Suite du chapitre sur les références

Comment accéder aux valeurs référencées ?

Exemple avec table de hachage :
«
my %maHash = ("cle1"=>"valeur1","cle2"=>"valeur2","cle3"=>"valeur3");
my $ref_maHash = \%maHash;
print $ref_maHash->{"cle2"}; #afficher « valeur2 »
»

Exemple avec tableau :
«
my @monTab = ("un", "deux", "trois");
my $ref_monTab = \@monTab;
print $ref_monTab->[1]; #affiche “deux”
»

On a aussi une autre écriture:

@{$ref_monTab} similaire à @monTab
Les accolades ont le sens du étoile (*monPointeur) en langage C.

${$ref_monTab}[0] similaire à $monTab[0]

%{$ref_monHash} similaire à %monHash
${$ref_monHash}{« cle2 »} similaire à $monHash{« cle2 »}

On peut aussi, si $ref a été déclaré en \@monTab( ou \%maHash), supprimer les accolades :

@{$ref_monTab} similaire à @$ref_monTab
${$ref_monTab}[0] similaire à $$ref_monTab[0]
%{$ref_monHash} similaire à %$ref_monHash
${$ref_monHash}{« cle2 »} similaire à $$ref_monHash{« cle2 »}

III.q) Gestion de la mémoire

Le programmeur Perl n’a pas à se soucier de la gestion de la mémoire en Perl( ni de la demande d’allocation, ni de la libération). Perl compte le nombre de références sur chaque valeur, et si elles ne sont plus référencées elles sont alors détruites.

III.r)Les expressions régulières

On utilise l’opérateur =~ ( ressemble à). Le contraire de cet opérateur est !~(ne ressemble pas à).

Exemple :

my $mot = 'erer0123456fap';
if ( $mot =~ '\d{6}' ) #ou bien =~ /\d{6}/
{
print "OUI\n";
}
else
{
print "NON\n";
}
Affiche « OUI » ici, car ‘\d{6}’ signifie qu’on recherche un motif de six chiffres au moins( ici on en a 7, donc on a au moins nos six chiffres qui se suivent). Et ce motif ne commence pas forcément en début de chaîne.
- Ajouter un ^ AU DEBUT signifie « débute par ». Sinon signifie « tout sauf ».
Ici, en mettant '^\d{6}' comme expression régulière, on aurait eu « NON ».
- Pour forcer à reconnaître 6 chiffres au plus, il faut rajouter $ à la fin de l’expression régulière, qui signifie « fin de chaîne ». Ici on écrirait if ( $mot =~ '\d{6}$' ), et le résultat affiché serait un ‘NON’, car on n’a pas la fin de chaîne après le sixième chiffre du motif rencontré.
- On peut écrire $mot =~ /\d{6}/ au lieu de $mot =~ '\d{6}' (le slash entoure l’expression régulière)
- On remarque que pour tester si un mot a une certaine structure, if faut utiliser une expression régulière commençant par ^ et finissant par $ : / ^… $/
- Le ‘\’ précède les caractères spéciaux. Par exemple, les parenthèses $ ou $ .
\d signifie « n’importe quel chiffre ».
\D signifie « tout ce qui n’est pas chiffre ».
\w signifie « n’importe quelle lettre ».
\W signifie « tout ce qui n’est pas lettre ».
\n caractère de fin de ligne
- [ ] : un caractère, et on définit l’intervalle à l’intérieur des crochets. Exemple : [a-z](une lettre entre ‘a’ et ‘z’), ou encore [abc](une lettre a, b ou c).
- {4} signifie le nombre d’occurrences, ici 4 chiffres.
- {a,b} signifie de a à b fois.
- Le point « . » signifie n’importe quel caractère(sauf le caractère de fin de ligne).
Ainsi /^.{1,5}$/ signifie : si c’est le mot comparé à l’expression régulière est un mot composé de 1 à 5 caractères, donc on teste si la longueur du mot est inférieur ou égal à 5 caractères, et que la chaîne est non vide.
Le | signifie « ou bien ». Par exemple : si le mot est ‘jean’ ou ‘pierre’.

my $mot = 'pierre';
my $expr = '^jean$|^pierre$';
if ( $mot =~ $expr )
{
print "OUI\n"
}

On remarque aussi dans cet exemple qu’on a mis l’expression régulière dans une string.

III.s)Les fichiers

III.s.1)Ouverture de fichier

Exemple : open( MONFIC, ‘monfichier.txt ‘) ;
On associe un descripteur de fichier(filehandle), qui est MONFIC ici, à notre fichier.
Ce descripteur de fichier sera utilisé ensuite lorsqu’on voudra parler de notre fichier.
On remarque que MONFIC n’est pas une variable( on ne met pas $MONFIC, et on ne la déclare pas avant).

Ouverture en écriture, exemple :
open( FSORTIE, ‘>/home/monFic.txt’) ;
Ceci va créer le fichier s’il n’existait pas. S’il existait déjà, l’ancien contenu sera écrasé.

III.s.2)Lecture dans un fichier

Lecture d’une ligne :

$ligne = readline( *MONFILEHANDLE) ;

Si les lignes ont une syntaxe CSV( des champs séparés par des points-virgules « ; »), on peut mettre directement
@ligne = readline( *MONFILEHANDLE) ;

On récupère alors dans le tableau, directement, chaque champ :
$ligne[0] : le premier champ de la ligne, $ligne[1], le deuxième champ de la ligne, etc.

Et @ligne est égal à 0 si on demande une ligne alors que fin de fichier.

III.s.3)Ecriture dans un fichier

Print FSORTIE ‘Bonjour’ ;

Fermeture de fichier :
close MONFILEHANDLE ;

IV)La programmation objet en PERL

Disponible depuis PERL 5( pas dans PERL 4).

Une classe est appelée « package ». Une classe est un package en réalité en perl.
Pour créer une classe, on crée un fichier Perl, d’extension .pm, qui contient la classe.

IV.a) Les variables de classes

En fait, ce sont des variables propres au paquetage, donc :

our $maVar ;
à mettre dans le paquetage(donc dans la classe !).

La syntaxe est la même que pour le mot-clé my.

Pour utiliser la variable en-dehors de son paquetage :
$MonPaquetage ::maVar ;
C’est logique, c’est comme si le nom de la variable devenait MonPaquetage ::maVar.

Pour utiliser un package : mettre dans le programme qui va se servir de votre package, au début par exemple :
use monPackage;

V)Divers

La fonction sprintf : comme printf, mais pour mettre le résultat dans une variable, au lieu de l’afficher à l’écran.

RETOUR HAUT