Cours sur le langage

PERL

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

Jacquenod Frédéric        

 

) : frederic.jacquenod@jacquenod.net

 

Web: http://portail.jacquenod.net

 

 

I Introduction

II Premiers pas

III Les variables simples et composées

 

III.1 Les chaînes de caractères

III.2 Les nombres

III.3 Les listes

III.4 Les tableaux associatifs

III.5 Les bases de données et les tableaux dbm

III.6 Remarque

 

IV Les entrèes-sorties

 

IV.1 Lecture des données

IV.2 Ecriture des données

 

V Les opérateurs de test et les expressions régulières

 

V.1 Les opérateurs de test

V.2 les expressions régulières

 

VI Les conditions et les boucles

 

VI.1 Les conditions

VI.2 Les boucles

 

VII Les Fonctions

 

VII.1 Création d’une fonction

VII.2 Quelques fonctions systèmes utiles

 

VIII Autres éléments du langage

 

VIII.1 Les paquetages

VIII.2 Les modules

I Introduction

 

Il y a une multitude d'autres langages dans le monde informatique (ADA, Cobol, C, Lisp,prolog, Ksh, Fortran, java ...).

Alors pourquoi utiliser PERL alors que de nombreux autres langages existent et que vous connaissez peut être l'un de ces langages ?

Ils ne se valent pas tous, ne sont pas toujours adaptés au travail que l'on veut faire, au problème à résoudre. Certains sont très hermétiques car trop proches du langage machine (...), d'autres assez complexes à utiliser (C, C++ ...), d'autres encore, très universitaires mais peu adaptés à l'entreprise (Pascal).

Le PERL (Pratical Extraction and Report Language) qui signifie littéralement Extraction Pratique et langage de Rapport, n'est ni un langage compilé, comme peuvent l’être le C, le pascal, le fortran ... ni un langage proprement dit interprété comme peuvent l’être le Korn Shell, awk...; mais un mixte des deux. Le "moteur" perl, analyse tout d'abord le programme en entier (afin de trouver d’éventuels erreurs de syntaxe), et seulement ensuite il l’exécute mais son exécution ne nécessite aucune compilation et aucune création d'objets.

Ce langage n'est pas typé, comme le C. Il ne nécessite aucune déclaration de type d'objets avant de les utiliser ce qui facilite largement les choses. La base de travail en PERL est la variable scalaire qui peut contenir, une chaîne de caractères comme un nombre ou une référence style pointeur. Ce langage de part les éléments qu'il propose est très simple d'utilisation pour des traitements de chaînes, des séquences, des recherches d’occurrences ...

Il est notamment utilisé dans des entreprises de traduction automatiques de langages style Systran. De mon coté je l'utilise beaucoup pour des programmations automatiques (statistiques, traitement de fichiers mot de passe ...) ainsi que pour réaliser des traitements de données provenant de formulaires sur l'internet comme langage pour mes CGI (questionnaires, statistiques ...).

De plus ce langage a le gros intérêt d’être gratuit, et assez facilement installable sur votre machine linux, macintosh, windows ... On le retrouve sur toutes les plates-formes. Il existe aussi de nombreux packages crées par la communauté des programmeurs pour vous faciliter le travail (Fonctions mathématiques ...).

 

Pour utiliser PERL il suffit de l'installer, de disposer les instructions dans un fichier texte, de le rendre exécutable (droit x sous unix), lisible (droit r sous unix) et de taper en ligne de commandes le nom de ce fichier pour que l’exécution commence. Ne pas oublier dans ces instructions le chemin d'accès de votre moteur PERL. Sous unix pour le connaître tapez :

which perl, si celui-ci est normalement installé vous devriez obtenir une réponse du type :

/usr/local/bin/perl

 

Nous travaillerons sur plate-forme unix, avec le perl version 5. Ce cours est orienté traitement automatique de données en provenance du web.

 

*J'ai bâti ce cours à partir des informations provenant de l'internet notamment la documentation du CPAN (Comprehensive Perl Archive Network) que vous pouvez retrouver sur le site : http://www.perl.com

 

*ainsi que sur deux livres aux éditions O'Reilly

"Introduction à PERL" et "PERL en action".

 

 

Vous trouverez d’autres aides et informations dans les sites suivants :

 

*www.search.cpan.org

 

 

*Pour récupérer la distribution, le site ftp de jussieu est un bon point de départ

ftp.jussieu.fr/pub/perl/CPAN

 

 

*Le site www.perl.org peut aussi vous donner quelques informations notamment pour acheter les t-shirt et autres casquettes à l’effigie de Perl J

 

 

 

*Et pour ceux qui veulent devenir des gourous du Perl et rester à l’affût de tout ce qui se fait de nouveau, ou tout simplement pour trouver de l’aide parmi les perliens, regardez les newsgroup :

 

 

II Premiers pas

 

J'ai choisi de bâtir mon cours de la manière suivante :

/chaque partie importante possède son propre chapitre comme ça pas de jaloux.

/je proposerai une série d’exercices pour illustrer chaque partie du cours.

 

 

 

C’est en forgeant que l’on devient

 

 

/Deux ou trois petites choses avants de débuter dans le monde PERL qui est un bijoux comme langage (Il fallait oser, je l'ai fait ...).

/Je vous ai indiqués dans l'introduction que pour utiliser perl il fallait l'avoir installer et savoir où il se situait dans l'arborescence de votre machine. La première ligne à mettre dans votre fichier texte (exemple : traite.pl) sera celle l'indiquant. Exemple, le moteur perl se situe dans le répertoire /usr/local/bin.

Indiquez dans votre fichier la directive suivante :

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

Explication : Si vous omettez cette ligne, l'interpréteur utilisé sera le shell utilisé lors de votre connexion sur la machine à savoir ksh, bash ... qui ne connaissent pas du tout le langage perl. Vous aurez alors une erreur dès la première ligne.

Le -w à la fin permet d'obtenir en cas de problème des messages plus clairs et des avertissements (warning) en cas de doutes lors de l’exécution.

Vous pouvez sinon tapez en ligne de commande directement :

> /usr/local/bin/perl -w traite.pl

/Les commentaires sont préfixés par le caractère #.

Ne pas confondre avec la directive précédente où vous associez le # avec le !.

Usez de ces commentaires, très utiles pour une personne qui reprend votre programme ou même pour vous pour savoir ce que vous faites, ou quels sont les formats des données à cette ligne là ...

/N'oubliez pas que votre fichier traite.pl doit être exécutable et lisible (interpréteur).

chmod u+rx traite.pl suffit si vous seul l’exécutez.

Précision : si votre programme perl doit servir de script cgi pensez que c'est le propriétaire du serveur web qui doit pouvoir exécuter ce programme (Voir partie Installation d'un serveur web Apache dans le cours Réseau). Il vous faudra alors donner les droits d’exécution, certainement, à tous (chmod o+rx traite.pl).

 

Voilà vous êtes parés pour débuter ... Bon courage.

 

III Les variables simples et composées

 

Le langage perl a un avantage indéniable par rapport aux langages C, pascal ... il ne nécessite pas de typer et de déclarer les éléments que l’on va utiliser (tableaux, chaîne de caractère ...). Vous voulez une chaîne de caractères, ou un nombre, la syntaxe est la même. Pas besoin d’indiquer que la variable sera de type entière, réelle, caractère ...

Seul le préfixe ($ , @, %) du nom de votre variable va déterminer si c’est une chaîne, une liste ou un tableau associatif. Ce que vous rangez dedans est presque accessoire.

 

III.1 Les chaînes de caractères

 

1. Présentation

 

Nous allons étudier dans cette partie, comment utiliser une chaîne de caractères

ainsi que les différentes opérations qui peuvent être effectuées.

Attention, la chaîne de caractères est une entité « entière » ; c’est à dire que vous ne pouvez pas accéder à un élément particulier via un indice comme en langage C par exemple chaîne[1]. Vous devez passer par des fonctions pour pouvoir le faire.

Lorsque vous utilisez une chaîne de caractères, pas besoin d’en indiquer la taille. Ici aussi c’est un gros avantage sur d’autres langages. Que vous rangiez un caractère ou 1000, la syntaxe est la même. Perl se débrouille pour gérer l’espace mémoire.

 

 

2. Notation 

 

Une chaîne est définie par le préfixe : $  (dollar)

$variable correspond à une chaîne de caractères appelée variable.

3. Affectation 

 

Une affectation se fait tout simplement en utilisant des apostrophes doubles ou des apostrophes simples.

 Attention la signification n’est pas la même.

 

$variable = “ truc chose” ; -> truc chose

$variable = “ \n” ; -> retour chariot

$variable = “ $chaine1” ; -> contenu de la variable chaine1

 

$variable = ‘\n‘ ; -> \n La chaîne a pour valeur les deux caractères \ et n

$variable = ‘$chaine1’ ; -> $chaine1

 

Pour introduire dans la valeur un caractère spécial utilisez des antislash (\) pour désactiver son caractère particulier.

 

$variable = “ truc \”  chose” ; -> truc “  chose

$variable = ‘j\’ai vu l\’armoire bretonne’ ; -> j’ai vu l’armoire bretonne

 

Si vous avez un texte, contenant des apostrophes simples ou doubles, a affecter à une chaîne de caractères, il peut être fastidieux de les décommenter  à chaque occurrence. Vous pouvez utiliser alors deux moyens.

 

a. Le caractère q permet d’utiliser d’autres délimiteurs que les apostrophes.

Le / ou des délimiteurs qui s’ouvrent et se referment.

 

$variable = q/j’ai vu l’armoire bretonne/; -> j’ai vu l’armoire bretonne

$variable = q{j’ai vu l’armoire bretonne}; -> j’ai vu l’armoire bretonne

$variable = q[j’ai vu l’armoire bretonne]; -> j’ai vu l’armoire bretonne

$variable = q(j’ai vu l’armoire bretonne); -> j’ai vu l’armoire bretonne

$variable = q<j’ai vu l’armoire bretonne>; -> j’ai vu l’armoire bretonne

 

b. Vous pouvez utiliser un document « ici-meme ». Vous donnez un délimiteurs qui sera un mot clé. Ce mot clé devra être seul sur la dernière ligne pour clore l’affectation.

 

$variable << “FIN” ;

J’ai vu l’armoire bretonne, ce n’est pas une FIN en soi mais

elle se nomme “ L’Armoire” avec un grand A.

FIN

-> j’ai vu l’armoire bretonne, ce n’est pas une FIN en soi mais

elle se nomme “ L’Armoire” avec un grand A.

 

4. Autres chaînes

 

. La seule chaîne non définie est undef. On la retrouvera dans les tests booléens, ouverture de fichiers ...

. La chaîne vide : $chaîne = “ “ ;. Cette chaîne est définie mais a une valeur logique égale à faux.

. La chaîne qui a la valeur 0 : $chaîne = “0” ; a aussi une valeur logique égale à faux.

 

. Une chaîne particulière est $_. $_ est la variable globale par défaut si aucune n’est spécifiée. Si vous lisez le contenu d’un fichier avec une boucle while et que vous ne spécifiez pas de chaîne pour récupérer les valeurs lues, elles seront alors rangées dans la variable $_. On peut omettre $_, c’est la variable par défaut.

 

while(<fichier>)

 

while($_ = <fichier>)

 

while($ligne = <fichier>)

{

 

{

 

{

 chop ;

 chop $_ ;

chop $ligne; # on utilise une

 print ;

 

 print $_;

 

print $ligne; # variable: $ligne

}

 

}

 

}

 

III.2 Les nombres

 

1. Présentation

 

Comme vu précédemment, Perl ne se soucie pas du type de la variable utilisée. Si vous l’utilisez comme un nombre, perl transforme le contenu en nombre, à contrario si vous l’utilisez comme des caractères, perl transforme le contenu en caractères.

La lecture d’un fichier donnera donc moins de soucie qu’avec un langage typé. Vous lisez les éléments de la même façon, seul l’utilisation à posteriori déterminera le type de la variable. Elle peut d’ailleurs être utilisée à un, moment donné comme une chaîne de caractères puis la ligne suivante comme une variable contenant un nombre.

Attention tout de même, si une variable est utilisée pour contenir des nombres, perl transforme les éléments non numériques en zéro et s’arrête lors de cette transformation dès qu’il qu’il trouve le premier élément non numérique.

Exemple : B52 vaut en nombre 0 tandis que 52B vaut 52. (mince mon numéro de carte bleue ...). Vous aurez d’ailleurs un warning au moment de l’exécution du programme.

 

2. Notation

 

La notation est la même que pour les chaînes de caractères ; préfixe $ (dollar).

 

$variable = “23” ; ou $variable = 23 ;

 

La valeur 0 a pour valeur booléenne la valeur fausse.

Vous pouvez comparer dans vos tests ces valeurs au mot clé false.

 

Les valeurs hexadécimales sont notées : 0x...

0xf représente la valeur 15 en décimale. 0xff représente la valeur décimale 255 (1 octet plein)

 

Nous verrons des fonctions pour obtenir des nombres aléatoires dans la partie VII.

III.3 Les listes

 

1. Présentation

 

La liste est une suite d’éléments, chaînes de caractères ou nombres ou les deux.

Les listes sont rangées dans des tableaux. Pour perl la distinction entre une liste et un tableau est assez subtile.

La liste est le terme utilisé pour définir le contenu, les éléments.

Le tableau est la variable, la structure qui référence ce contenu.

La suite des éléments étudiants, note, 0 est une liste. La variable controle qui contient ces trois éléments est un tableau. Vous travaillerez donc sur les tableaux mais pas directement sur les listes.

 

Exemple parlant :

Prenons ce superbe pot de cornichons.

 

 

/La liste est constituée des éléments que sont les cornichons, le vinaigre, les aromates ...

 

/Le tableau lui est le pot qui contient ces cornichons.

 

Frappant non !

 

Les éléments d’un tableau sont rangés dans un ordre référencé par des indices. Ces indices commencent par 0. Vous pouvez donc atteindre un élément directement via son indice, à la différence de la chaîne simple vue précédemment.

 

2. Notation

 

Le préfixe @ permet de déterminer que c’est un tableau.

La notation est la suivante : @pot

 

3. Affectation

 

L’affectation se fait de la manière suivante :

 

@pot = (“cornichon1”,”vinaigre”,”aromates”) ;

bleu -> tableau

rouge -> liste

 

L’élément cornichon1est situé à l’indice 0 du tableau pot et peut être atteint grâce à la notation suivante :

$pot[0]

$pot[1] est l’élément vinaigre du tableau pot.

Un élément du tableau est une chaîne de caractères d’où la notation $.

 

4. Deux ou trois choses à savoir pour vous simplifier la vie

 

/Le tableau @_ est particulier. Il est utilisé dans les fonctions (Voir chap VII Les fonctions). Lorsque vous passez des arguments lors de l’appel de la fonction, ceux-ci sont rangés dans le tableau @_. La première valeur sera donc dans $_[0], la deuxième dans $_[1] et ainsi de suite.

Attention, lorsque vous utilisez des paquetages et que vous appelez une fonction le premier élément n’est pas la valeur passée mais le nom du paquetage.

Voir la partie sur les paquetages partie VIII.

 

Définition

 

sub calcul {

 return  $somme = $_[0] + $_[1] ;

}

 

Appel 

 

print calcul(2,3); -> 5

 

/Imaginez que votre pot de cornichons soit plein. Vous venez de l’acheter par exemple. Vous voulez connaître le nombre d’ingrédients qui composent votre pot.

Vous pouvez tout sortir et les compter, pas très simple. Vous avez avec perl un moyen simple.

Pour déterminer rapidement le nombre d’éléments contenus dans un pot oups dans un tableau, il suffit de travailler sur les références (les pointeurs), et utiliser :

 

$nombre = @pot ; -> $nombre vaut alors 3

 

/Vous pouvez aussi vouloir le nombre d’indices :

 

$#nombre = @pot ; -> $#nombre vaut alors 2 (les indices commencent à 0)

 

/Ajouter un élément simplement à votre tableau :

 

@pot = (@pot,”colorants”) ; -> vous avez maintenant 4 éléments

 

/Récupérer rapidement des éléments du tableau :

 

@pot[0..2]; -> Vous obtenez les 3 premiers éléments cornichon1 vinaigre aromates

 

/Effectuer des inversions dans le tableau :

 

@pot[1,2] = @pot[2,1]; ->  la liste cornichon1 vinaigre aromates colorants  

devient cornichon1 aromates vinaigre colorants

 

 

III.4 Les tableaux associatifs

 

1. Présentation

 

Ces tableaux particuliers sont aussi appelés hachages ou tables.

Ils permettent d’associer deux éléments en en faisant une paire.

Le premier étant la clé et le deuxième la valeur.

Le couple est (clé,valeur).

La clé peut être n’importe quoi (chaîne de caractères, nombre ...).

 

2. Notation

 

Le préfixe est alors % (pourcent).

 

3. Affectation

 

L’affectation se fait de la façon suivante :

 

%note =(“etudiant1”, 10,

“etudiant2”,9,

“etudiant3”,”absent”,

“pot de cornichons”, ”12 francs 50”) ;

 

Vous pouvez aussi tout mettre linéairement.

 

%note =(“etudiant1”, 10, “etudiant2”,9,”etudiant3”,”absent”,”pot de cornichons”, ”12 francs 50”) ;

 

Ou encore :

 

%note =(“etudiant1” => 10,

“etudiant2” =>9,

“etudiant3” =>“absent”,

“pot de cornichons” =>“12 francs 50”) ;

 

 

Dans ces trois cas les couples sont (etudiant1,10) ; (etudiant2,9) ; (etudiant3,absent) et (pot de cornichons, 12 francs 50). Le premier élément contenu dans la parenthèse est la clé (l’indice) et le deuxième la valeur.

Pour atteindre directement le couple (pot de cornichons, 12 francs 50) il faut utiliser la notation :

 

$note{“ pot de cornichons”}; -> on obtiendra la valeur 12 francs 50

 

 Attention afin d’optimiser les extractions d’éléments, perl réordonne à sa manière les couples dans le tableau associatif. Ainsi si vous entrez les couples dans un certains ordre, vous pouvez être assuré(e) qu’elles ressortiront en « désordre ».

Le premier élément entré ne sera pas forcément en première position dans votre tableau associatif.

 

L’extraction des couples se fait avec des opérateurs tels foreach que l’on verra dans la partie VI.

 

Il existe un hachage intéressant contenant les variables d’environnement : %ENV.

 

$ENV{“PATH”};-> vous obtiendrez sous système unix et  linux, la valeur de votre variable d’environnement PATH

 

 

III.5 Les bases de données et les tableaux dbm

 

1. Présentation

 

Ce système est une bibliothèque qui fournit un utilitaire simple de gestion de base de données en stockant des paires (clé,valeur) sur disque.

Une fois ouverte, toutes les manipulations seront répercutées dans  les fichiers sur disque.

 

Attention à la fin de chaque clé un caractère NULL est ajouté au moment du stockage. Il faut donc pour récupérer une valeur procéder de la manière suivante :

 

$val = $tab{"cle\0"};

chop($val);   # pour l'affichage

 

Vous pouvez utiliser en perl 5 la fonction chomp un peu plus puissante.

2. Pour associer une base de données dbm à un tableau dbm

 

dbmopen(%tableau_associatif,"dbmfichier",$mode);

 

Le premier paramètre est un tableau associatif

Le deuxième paramètre est la base de données composée de deux fichiers    dbmfichier.dir et dbmfichier.pag

Le troisième paramètre est le mode d'accès en octal du fichier. Si le fichier existe déjà ce paramètre n'est pas utile et peut être remplacé par la valeur indéfinie undef.

 

3. Pour stopper l’association entre le tableau et la base de données

 

       dbmclose(%tableau_associatif);

 

4. Pour accéder à des données ayant une taille fixe

 

Cette méthode permet d'atteindre les données (enregistrements) de manière plus rapide et plus direct en "sautant" autant d'octets que nécessaire.

 

- L'ouverture :

 

open(DESC,"mode");

Où mode est :       +<fic  on ouvre le fichier fic en lecture/Ecriture. Le fichier

doit déjà exister.

+>fic  on crée le fichier fic puis on l'ouvre en Lec./Ecr.

                           +>>fic on ouvre ou on crée (si fic n'existe pas) puis on ouvre

en Lect./Ecr.

       

- Le positionnement :

 

        seek(DESC,nb_octets_a_passer,position_de_départ);

 

- L'écriture :         

 

        print DESC données;

 

 Attention il est impératif que les données soient de la taille d'un    enregistrement. Une fonction est pratique pour faire cela : pack.

 

print DESC pack("format",$champ1,$champ2, ...);

 

Où format désigne le nombre d'octets de chaque champ.

Exemple : A40AA20s

          A40 indique que le premier champ sera formaté sur 40 octets

          A   indique que le deuxième champ sera formaté sur 1 octet

          A20 indique que le troisième champ sera formaté sur 20 octets

          s   indique que le quatrième champ sera formaté sur un entier court

              (2 octets)

 

- La lecture :

 

        read(DESC,$buffer,$nb_octets_a_lire);

 

La valeur de retour est le nombre d'octets lus.

Une fois l'enregistrement lu il faut récupérer chaque champ. Une fonction du même ordre que pack nous y aide : unpack.

L'enregistrement est stocké dans la variable buffer.

($champ1,$champ2,...) = unpack("format",$buffer);

(La partie format a été expliquée au dessus)

 

III.6 Remarque

 

 

$pot

@pot

%pot

sont trois entités différentes même si elles portent le même nom. Il est préférable pour la compréhension d’éviter cela. Ne rajoutez pas de difficultés pour rien.

 

 

IV Les entrèes-sorties

 

 

IV.1 Lecture des données

 

 

stdin est l'entrée standard par défaut.

Chaque élément lu conserve en dernier caractère le retour chariot (\n) d'où l'utilisation d'une commande supprimant le dernier caractère d'une variable : chop.

 

1. Au clavier

  

$name  = <stdin>;

Le retour chariot termine la lecture

 

@liste = <stdin>;

Chaque ligne entrée est un élément du tableau. Il est nécessaire de finir par <ctrl><d>

 

En boucle (pour terminer la boucle <ctrl><d>) :

 

while(<>)

{ print "la valeur : $_\n"; }

<> est l'opérateur diamond

$_ est la variable de stockage par défaut si aucune n'est précisée

 

Ou

    

while($valeur = <stdin>)

{ print "la valeur : $valeur\n"; }

       

2. Dans un fichier

 

Tout comme dans la majorité des langages, il est nécessaire d'ouvrir le fichier, de récupérer les données et de le refermer.

 

open(DESC,"fichier");              # On ouvre le fichier

while($valeur = <DESC>)        # On lit les données par lignes

{

   chop($valeur);                      # On supprime le retour chariot

    print "la valeur : $valeur\n";  # On affiche la valeur lue

}

close(DESC);                          # On ferme le fichier

 

On pourrait pu, comme précédemment, utiliser la variable par défaut :

 

open(DESC,"fichier");              # On ouvre le fichier

while(<DESC>)                      # On lit les données par lignes

{

   chop;                                  # On supprime le retour chariot

   print "la valeur : $_\n";         # On affiche la valeur lue

}

close(DESC);                          # On ferme le fichier

 

3. En ligne de commande lors du passage de paramètres

 

Les arguments sont stockés dans un tableau prédéfini : @ARGV

 

$ARGV[0] -> premier paramètre

 

Si il n'y a pas de paramètre @ARGV renvoie '-' ou $#ARGV -1

 

if(@ARGV == '-') {print "Aucun paramètre sur la ligne de commande\n";}

 

Ou

 

if($#ARGV == -1) {print "Aucun paramètre sur la ligne de commande\n";}

 

 

IV.2 Ecriture des données

 

stdout est la sortie standard par défaut.

Le backslash (\) permet de désactiver la spécificité de certains caractères.

  

1. Sortie simple

 

a. A l'écran

 

simple   :

 

print "Je suis sur votre écran\n";

print "la valeur est : $tab{\"cle\"}\n";

 

Vous pouvez aussi utiliser les syntaxes suivantes si vous préférez.

print "Je suis", "sur votre écran\n";

print "Je suis"."sur votre écran\n";

print("Je suis sur votre écran\n");

 

formaté :

 

printf "%6s %3d %4.2f\n",$s,$d,$f;

%6s   sortie caractère sur 6 caractères

%3d   sortie d'un entier sur 3 caractères

%4.2f sortie d'un réel sur 4 caractères dont 2 après la virgule           

 

b. Dans un fichier

 

DESC est le descripteur du fichier de sortie à ouvrir avant l'écriture grâce à la commande open. N'oubliez pas de le fermer au moyen de la commande close.

Les différents formats d’ouverture sont :

 

open(DESC,"mode");

Où mode est :       +<fic  on ouvre le fichier fic en lecture/Ecriture. Le fichier

doit déjà exister.

+>fic  on crée le fichier fic puis on l'ouvre en Lec./Ecr.

                           +>>fic on ouvre ou on crée (si fic n'existe pas) puis on ouvre

en Lect./Ecr.

 

simple   :

 

print DESC "Je suis dans votre fichier\n";

 

formaté  :

 

printf DESC "%6s %3d %4.2f\n",$s,$d,$f;

 

2. Sortie formatée en utilisant le mot clé format

 

Ce type de sorties permet d'avoir un affichage plus précis avec un format prédéfini (un peu comme avec un printf mais plus simple d'utilisation et plus puissant).

Pour définir un format vous devez utiliser le mot clé format, le définir puis afficher vos résultats au moyen de la commande write.

   

* Description d'un format :

 

format nom_du_format =

descriptif de la sortie

.

   

* nom_du_format :

 

2 types de nom sont possibles, pour l'entête et pour le corps de l'affichage. (NOM_TOP et NOM)

 Attention : N'oubliez pas le caractère . (point) qui termine la définition d'un format. Ce point doit être en première colonne dans votre fichier sinon vous risquez d'avoir une erreur.

 

descriptif de la sortie :

Ce descriptif comprend 2 parties essentielles le format d'affichage et  les variables à afficher.

  

1. le format d'affichage

   

Cette partie permet de connaître la façon dont vont être  affichées les données (l'endroit, la manière, la taille ...). La taille est définie par le nombre de signes présents après le signe @  ou ^

 

@>>>> indiquera que la valeur sera affichée sur 4 caractères justifiés à droite

@<<<< même chose mais justifié à gauche

@|||| même chose mais centré 

@###.## champ numérique avec 2 chiffres après la virgule

@* champ multiligne, on ne s'occupe pas de la taille du champ à afficher

^>>> affichera un champ sur plusieurs lignes de 3 caractères (lignes vides incluses)

~ ^>>> même chose mais sans les lignes vides

~~ ^>>> même chose mais répétera l'affichage jusqu'à trouver une ligne vide

 

2. les variables à afficher

 

$variables1,$variables2, ....

      

* Affichage à l'écran :

   

Le nom du format sera STDOUT qui par défaut est la sortie standard.

STDOUT_TOP sera le nom du format pour l'entête.

 

* Affichage dans un fichier :

 

Le nom du format sera le nom du descripteur du fichier (par exemple DESC).

DESC_TOP sera le nom du format pour l'entête.

    

* Quelques exemples :

 

Problématique : On désire écrire les noms et prénoms des personnes contenus dans un tableau associatif par colonnes avec comme entête les mots Nom Prénom et le contenu du tableau :

 

format STDOUT_TOP =         # Permet d'écrire la première ligne

Nom Prénom                          # La première ligne

.                                           # Fin du format pour l'entête

format STDOUT =                                   # Permet d'écrire les données formatées

@>>>>>>>> @>>>>>>>>>>     # Format d'affichage des 2 champs justifié            

                                                     # à  droite

$nom, %tab{$nom}                         # nom sur 8 caractères et le prénom sur 10

.                                                    # Fin du format

foreach $nom (keys %tab)       # boucle permettant l'affichage du tableau

{

  $prenom = $tab{$nom};

   write;

}

   

Attention : Ne pas mettre de commentaires comme ici dans la définition

d'un format ceux-ci seraient affichés lors de l'affichage.

 

Problématique : On désire faire la même chose mais dans un fichier.

Nous allons donc nommer le format du nom du descripteur du fichier.

 

format DESC_TOP = ...          # Sera l'entête lors de l'affichage dans le fichier

                                            # référencé par le descripteur DESC

format DESC = ...                  # Sera le format d'affichage du corps

                                            # dans le fichier

open(DESC,">fichier");          # On ouvre en écriture le fichier "fichier"

                                            # référencé par le descripteur DESC

foreach $nom (keys %tab)       # boucle permettant l'affichage du tableau

{

  $prenom = @tab{$nom};

   write DESC;                       # On affiche les résultats dans le fichier

}

close(DESC);                         # On ferme le fichier

 

3. Caractères spéciaux

 

Lors de la sortie écran, certains caractères précédés d’un antislash permettent d’effectuer des opérations particulières.

 

Fonction

Exemple

Résultat

\n

 

Passage à la ligne

\r

 

Retour chariot

\t

 

Tabulation

\f

A tester

Passage à la page suivante

\b

 

Retour en arrière

\v

 

Tabulation verticale

\a

 

Bip sonore

Transformations en  majuscules ou minuscules

\U 

print “\Ufred”; 

 FRED -> Tous les caractères en majuscule

\u 

print “\ufred”; 

 Fred -> Le premier caractère en majuscule

\L 

print “\uFRED”; 

 fred -> Tous les caractères en minuscule

\l 

print “\lFRED”; 

 fRED -> Le premier caractère en minuscule

 

 

V Les opérateurs de test et les expressions régulières

 

V.1 Les opérateurs de test

 

1. Les opérateurs appliqués aux chaînes de caractères

 

Opérateurs de comparaison

Opération

Opérateur

Exemple

Conditions logiques

Egal

eq

$a eq $b

Vrai si $a égal à $b

Différent

ne

$a ne $b

Vrai si $a est différent de $b

Inférieur

lt

$a lt $b

Vrai si $a inférieur à $b

Inférieur ou égal

le

$a le $b

Vrai si $a inférieur ou égal à $b

Supérieur

gt

$a gt $b

Vrai si $a supérieur à $b

Supérieur ou égal

ge

$a ge $b

Vrai si $a supérieur ou égal à $b

 

 

 

 

Opérateurs logiques

Opération

Opérateur

Exemple

Conditions logiques

Et

&&

$a && $b

Vrai si $a est vrai et si $b est vrai

 

and

$a and $b

Vrai si $a est vrai et si $b est vrai

Ou

||

$a || $b

Vrai si $a est vrai et/ou si $b est vrai

 

or

$a or $b

Vrai si $a est vrai et/ou si $b est vrai

Négation

!

!$a

Vrai si $a est faux

 

not

not $a

Vrai si $a est faux

 

 

 

 

Autres opérateurs

Opération

Opérateur

Exemple

Conditions logiques

Concaténation

.

$c =$a . $b

$a=“vin” et $b=“aigre” alors $c=“vinaigre”

Incrémentation

++

$a++

$a=“fred” -> free

Décrémentation

--

$a-- 

Testez mais ne fonctionne pas

Multiplication

x

$b = $a x 2

si $a=“cou” -> coucou

 

2. Les opérateurs appliqués aux nombres

 

Opérateurs de comparaison

Opération

Opérateur

Exemple

Conditions logiques

Egal

==

$a == $b

Vrai si $a égal à $b

Différent

!=

$a != $b

Vrai si $a est différent de $b

Inférieur

<

$a < $b

Vrai si $a inférieur à $b

Inférieur ou égal

<=

$a <= $b

Vrai si $a inférieur ou égal à $b

Supérieur

>

$a > $b

Vrai si $a supérieur à $b

Supérieur ou égal

>=

$a >= $b

Vrai si $a supérieur ou égal à $b

 

 

 

 

Opérateurs logiques

Opération

Opérateur

Exemple

Conditions logiques

Et

&&

$a && $b

Vrai si $a est vrai et si $b est vrai

 

and

$a and $b

Vrai si $a est vrai et si $b est vrai

Ou

||

$a || $b

Vrai si $a est vrai et/ou si $b est vrai

 

or

$a or $b

Vrai si $a est vrai et/ou si $b est vrai

Négation

!

!$a

Vrai si $a est faux

 

not

not $a

Vrai si $a est faux

 

 

 

 

Autres opérateurs

Opération

Opérateur

Exemple

Conditions logiques

Ajout

+

$c =$a + $b

$a=1 et $b=2 alors $c=3

Incrémentation

++

$a++

$a=1 -> 2

Décrémentation

--

$a-- 

$a=1 -> 0

Multiplication

x

$b = $a x 2

si $a=2 -> 4

Modulo

%

$c = $a % $b

reste de la division entre $a et $b

Puissance

**

$c = $a ** 2

$a puissance 2

 

La fonction or permet de ne faire évaluer que la première condition si elle est vraie.

Ceci est très utile lors de l’ouverture des fichiers. Vous pouvez ainsi utiliser la syntaxe suivante.

 

open(FICHIER,$nom) or die “Ouverture du fichier $nom impossible” ;

 

3. Opérateurs de tests sur les fichiers

 

L'utilisation peut être faite de cette manière :

  if( operateur $fichier_repertoire) ....

 

 

Opérateur 

   Signification

-r       

Le Fichier ou le Répertoire sont lisibles

-w       

F ou R modifiables

-x       

F ou R exécutables

-o       

F ou R propriétaire de l'utilisateur

-R       

 

-W       

Mêmes tests que précédemment mais en fonction

           

de la présence ou non d'un setuid

-X       

  

-O       

 

-e       

F ou R existent

-z       

F existe et sa taille est nulle

-s       

F ou R existent et sa taille est non nulle

-f       

C'est un Fichier

-d       

C'est un Répertoire

-l       

C'est lien symbolique

-b       

Fichier spécial de type bloc  (Disque ..)

-c       

Fichier spécial de type caractère (E/S ..)

-u       

F ou R disposant d'un setuid

-g       

F ou R disposant d'un setgid

-T       

Fichier de type texte

-B       

Fichier de type binaire

-M       

Age de la dernière modification en jours

-A       

Age du dernier accès en jours

-C       

Age de la dernière modification de l'inode en jours

 

 

V.2 les expressions régulières

 

Mais qu’est ce que c’est que cette chose ?

Tout simplement un étudiant qui ne bouge pas du début à la fin de mon cours.  Il a une expression régulière. Quoi c’est pas ça ?

 

1. L’opérateur =~

 

Un expression régulière est simplement une fonction dérivée de la commande sed qui permet de rechercher, de substituer des éléments dans une chaîne.

L’opérateur a utiliser est =~. Il faut l’associer aux opérateurs m// pour la recherche d’occurrences et s/// pour celui de substitution.

Vous pouvez les utiliser notamment lors de tests.

If($chaîne =~ m/aigre /) ... permettra de déterminer si dans la chaîne il y a l’occurrence aigre.

Si vous voulez modifier une occurrence dans une chaîne procédez comme suit :

$chaine2 =~ s/truc/chose/;

Les occurrences truc seront transformées en chose dans la chaîne chaine2.

Il y a de nombreuses combinaisons très pratiques, pour pouvoir utiliser au maximum cette facilité de traitement des chaînes regardez la documentation sur la commande unix : sed.

 

Vous pouvez aussi utiliser la fonction tr, que nous reverrons, pour effectuer une transformation d’éléments dans un chaîne.

$chaîne =~ tr/a-z//; Supprimera tous les caractères alphabétiques minuscules de la chaine $chaine.

 

2. Changement de taille des caractères

 

Fonction

Exemple

Résultat

\U 

 $a = “\Ufred”; 

 FRED -> Tous les caractères en majuscule

\u 

 $a = “\ufred”; 

 Fred -> Le premier caractère en majuscule

\L 

 $a = “\uFRED”; 

 fred -> Tous les caractères en minuscule

\l 

 $a = “\lFRED”; 

 fRED -> Le premier caractère en minuscule

 

 

VI Les conditions et les boucles

 

VI.1 Les conditions

 

1. if

 

On retrouve la syntaxe du C dans le if qui permet de tester une condition et d’effectuer selon le résultat une action ou une autre.

 

*Syntaxe

 

If(condition1)

{

 action si la condition1 est vraie ;

}

else

{

 action si la condition1 est fausse ;

}

 

*Exemples

 

if(“$a” eq “$b”){print “Egalité\n”;}

else

{print “Inégalité\n”;}

OU

(“$a” eq “$b”) ? print “Egalité\n”  : print “Inégalité\n”;

 

Il existe de nombreuses autres façons d’écrire la condition if. La première reste malgré tout celle que je recommande car elle est plus explicite que les autres et se retrouve dans de nombreux autres langages.

 

if( !open(FICHIER,$nomfichier))

{print “Problème d’ouverture du fichier $nomfichier” ;}

else

{

  print “Fichier $nomfichier ouvert\n” ;

  action

}

 

2. switch

 

Le switch en tant que tel n’existe pas en perl. Il peut être « émuler » avec des elsif

 

*Syntaxe

 

If(condition1)

{action si la condition1 est vraie ;}

elseif(condition2)

{action si la condition2 est vraie;}

elsif(condition3)

{action si la condition3 est vraie;}

...

else

{action si toutes les conditions précédentes sont fausses ;}

 

3. unless

 

*Syntaxe

 

Vous voulez réaliser une action si la condition est fausse, pour cela utiliser unless.

 

Unless(condition)

{action si la condition est fausse ;}

else

{action si la condition est vraie ;}

 

 

VI.2 Les boucles

 

1. for

 

Boucle permettant d'effectuer une action autant de fois que l'on désire.

  

*Syntaxe

 

 for(valeur_initiale;test;incrementation)

 {

  commande;

 }

  

*Exemple

  

for($i=1;$i<=10;$i++)

{

  print "Le numéro est $i\n";

}

 

2. while

 

Boucle permettant d'effectuer une action tant qu'une condition est vraie.

 

*Syntaxe

 

while(condition)

{

  instruction;

}

 

*Exemple

 

Avec cette boucle vous pouvez récupérer tous les éléments d’un tableau associatif (Voir aussi la boucle foreach).

 

while(($cle,$valeur) = each %hachage)

{

  print ”Le couple est : ($cle,$valeur)\n”;

}

 

3. until

   

Boucle permettant d'effectuer une action tant qu'une condition est fausse.

  

*Syntaxe

   

until(condition)

{

  instruction;

}

 

4. foreach

 

Cette boucle ne s’applique qu’au parcours d’éléments d’un tableau.

On peut aussi utiliser foreach pour récupérer, dans un tableau associatif, les clés de chaque couple et permettre ainsi d’extraire la valeur. On utilisera le mot clé keys.

 

*Syntaxe

 

foreach $cle (@liste)

{

  instruction;

}

 

*Exemples

 

@liste = (1,2,3,4);

foreach $element (@liste)

{

  print "l'element est : $element\n";

}

 

%tableau = ("aix","ibm","macos","macintosh") ;

foreach $cle (keys %tableau)

{

  $valeur = $tableau{$cle};

   print "la valeur $valeur est associée a la clé $cle\n";

}

  

 

VII Les fonctions

 

VII.1 Création d’une fonction

 

1. Présentation

 

Les sous-programmes permettent de développer de manière modulaire dans le cas ou plusieurs personnes se partagent le travail par exemple. Ils permettent aussi de structurer et de clarifier le programme. Si vous devez répéter plusieurs fois une même suite d’opérations dans votre programme, optez pour une fonction. Il suffira de l’appeler plutôt que de réécrire le code de plusieurs lignes.

Les fonctions sont aussi appelés sous-programmes d’où la notation pour indiquer que l’on crée une fonction sub (Pour subroutine traduction en anglais de sous-programme : sub pour sous et routine pour programme si si je vous assure J).

 

Les fonctions peuvent être situées dans le même fichier ou dans un fichier autre.

Dans ce cas il vous faudra utiliser les mots clés use, require ou do pour signifier au programme où elles sont situées. Nous reverrons cela plus tard dans ce cours.

 

Dans une fonction, sauf si vous l’indiquez, les variables sont globales. Elles gardent donc leurs valeurs une fois l’exécution de la fonction terminée.

 

Si vous n’utilisez pas l’instruction return pour renvoyer le résultat, c’est alors la valeur de la dernière expression qui est retournée.

 

2. Notation

 

Pour définir une fonction, la syntaxe est la suivante :

 

sub nom-de-la-fonction {

Actions ;

}

 

La partie entre {}, va déterminer les actions à effectuer. Il peut y avoir des définitions de variables locales, des passages d’arguments ...

 

L’appel dans le programme de la fonction se fera la plupart du temps de la façon suivante (cas le plus simple, pas d’arguments) :

 

nom-de-la-fonction();

 

 

3. Les arguments

 

Lorsque vous passez des valeurs en paramètres, ils sont alors rangés, comme nous l’avons déjà vu dans le tableau @_. Le premier argument est $_[0] et ainsi de suite.

 

4. Les variables

 

Lorsque vous utilisez des variables par défaut elles sont globales. Si une autre fonction utilise la même variable, celle-ci aura la valeur définie précédemment ce qui peut avoir des effets de bords importants et modifier le résultat.

Il peut être donc préférable de travailler dans une fonction sur des variables locales. Elles n’auront d’existence qu’a l’intérieur de la fonction, au delà elles ne sont pas connues. Pour cela il faut utiliser l’opérateur my.

my  va permettre de déclarer une variable qui aura une durée de vie uniquement dans la fonction.

 

*syntaxe

 

sub  calcul {

my $chaine_locale;

}

 

sub  ecriture {

my ($chaine_locale,@tableau_local,%hachage_local);

}

 

Dans le premier cas nous ne déclarons qu’une variable locale ou privée qui se nomme $chaine_locale. Mais rien ne nous empêche de déclarer en une seule fois plusieurs variables locales que ce soit une chaîne, un tableau ou un hachage.

 

En dehors de la fonction ces variables n’auront aucune existence.

 

La portée de cet opérateur est généralement limitée aux accolades.

Vous pourrez donc déclarer des variables locales dans des boucles, des tests.

 

for($i ;$i<=2 ;$i++)

{

 my $a;       # Variable locale à la boucle for

 $a = $i ;

 print $a;

}

print $a ;    # Warning la variable $a n’est pas initialisée et n’a pas de valeur

 

Vous pouvez initialiser la variable tout en lui affectant sa valeur. Imaginez que vous passez des paramètres à votre fonction calcul. Que ces paramètres vous voulez les manipuler mais uniquement localement et ne pas travailler sur le tableau initial @_ pour éviter des effets de bords dans le reste du programme.

 

sub  calcul{                            Ou              sub calcul {

my $argument1 = $_[0];                  my @argument = @_ ;

my $argument2 = $_[1];                  }

}

 

 

VII.2 Quelques fonctions systèmes utiles

 

1. chdir

 

Permet un changement de répertoire.

Renvoie vrai si le changement s'est bien passé.

 

*Syntaxe

 

chdir($chemin);

  

2. chmod

 

Permet de modifier les droits sur un ou plusieurs fichiers ou un ou plusieurs répertoires.

La valeur de retour de la commande est le nombre de modifications effectuées.

 

*Syntaxe

  

chmod($droits,$fichier1,$fichier2, ...);

$droit est en octal 0777 donnera tous les droits a tout le monde

 

On peut modifier plusieurs fichiers en utilisant une expression :

chmod(0777,<*.o>); changera les droits a tous les fichiers ayant l'extension .o

   

3. chop

 

Ce mot clé permet de supprimer le dernier caractère contenu dans une variable. Il est notamment très utile pour supprimer le retour chariot

lors de la lecture au clavier des données :

 

*Syntaxe

 

chop($variable);

 

4. chomp

 

Ce mot clé permet de supprimer les derniers caractères situés derrière le caractère \ en fin de variable. Il ressemble beaucoup à chop, mais permet de faire cette action sur des listes et non pas seulement sur des chaînes simples.

 

*Syntaxe

 

chomp($variable1, $variable2,..., @liste1,@liste2,...);

 

5. chown

 

Permet de modifier le propriétaire d'un fichier ou d'un répertoire.

Pour l'utiliser il vous faut avoir des droits particuliers la plupart du temps.

La valeur de retour de la commande est le nombre de modifications effectuées.

 

*Syntaxe

  

chown($uid,$gid,$fichier1,$fichier2,..);

$uid est le numéro d'identification de l'utilisateur

$gid est le numéro d'identification du groupe

 

6. closedir

 

Ferme un descripteur de répertoire.

 

*Syntaxe

 

closedir(descripteur);

 

voir aussi opendir, readdir

 

7. delete

 

Détruit un couple de valeur dans un tableau associatif.

 

*Syntaxe

 

delete($tab{$cle});

 

8. die

 

Permet de terminer un programme au moment ou on passe sur le die et de faire une sortie écran au même moment.

 

*Syntaxe

 

die "c'est la fin\n";

 

9.  each

 

Renvoie chaque éléments du tableau associatif.

Voir l’exemple avec la boucle while.

 

*Syntaxe

 

($cle,$val)=each(%tab);

 


10. eof

 

Permet de déterminer si la fin du fichier est atteinte.

 

*Syntaxe

 

eof(descripteur);   # renverra la valeur vraie si la fin est atteinte

                           # à utiliser avec une boucle while par exemple

 

 

11. exists

 

Permet de déterminer directement si un couple (cle,valeur) existe dans le hachage. Si le couple existe, la valeur vraie est retournée.

 

*Syntaxe

 

exists $hachage{$cle};

 

12. getc

 

Permet de récupérer un seul caractère lors de la lecture d’un fichier ou d’une saisie au clavier. Pour un fichier, faites une boucle de lecture avec un while par exemple.

Si vous ne précisez pas de descripteur de fichier, la lecture se fera sur l’entrée standard.

 

*Syntaxe

 

$c = getc(Descripteur);

 

*Exemple

 

while($c = getc(Descripteur))

{

 print “Caractère lu : $c\n”;

}

 

13. glob

 

Renvoie le fichier dont le nom est indiqué en argument de la fonction glob.

Les caractères de substitution sont autorisés (*, ? ).

Si vous n’indiquez pas de chemin de recherche, cette dernière se fera à l’endroit où vous êtes.

Si il y a plusieurs fichiers ayant la chaîne de recherche dans leur nom, seul le premier sera renvoyé. Pour obtenir tous les noms créez un boucle.

 

*Syntaxe

 

$recherche = glob(“chaine”);

 

*Exemple

 

while($recherche = glob(“/usr/local/bin/perl*”))

{

 print “$recherche”;

}

 

Vous obtiendrez tous les noms des fichiers commençant par la chaîne perl se trouvant dans le répertoire /usr/local/bin.

 

14. grep

 

Effectue une recherche dans tous les éléments d’une ou plusieurs listes en fonction d’une expression régulière indiquée en argument de la fonction.

Les valeurs retournées sont celles des éléments qui satisfont à cette recherche.

Elles sont stockées dans un tableau.

 

*Syntaxe

 

@resultat = grep(expression,liste1, liste2 ... listen);

 

*Exemple

 

@liste1=(“klm”,”mnop”,”xyz”,”12çà”);

@liste2=(“piste”,”poire”,”miam”,”beurk”);

@resultat = grep(/m/,@liste1,@liste2) ;

print “resultat”;

 

On recherche tous les éléments des listes contenant le caractère m.

Affichera les éléments klm,mnop et miam.

Toutes les expressions régulières sont possibles.

 

15. index

 

Renvoie l'emplacement d'une sous-chaîne de caractères dans la chaîne indiquée ou -1 si cette sous-chaîne n'existe pas.

Attention les indices commencent à l'indice 0.

La chaîne est parcourue par la gauche.

Le paramètre $position permet de faire un recherche à partir d'un indice précis.

 

*Syntaxe

  

index($chaine,$sous-chaine);

ou

index($chaine,$sous-chaine,$position);

 

16. join

 

Cancantène une valeur à chaque élément d'une liste et range le tout dans une variable.

 

*Syntaxe

  

join($valeur,@liste);

 

17. keys

 

Permet de récupérer dans un tableau associatif la clé ou les clés dans un ordre quelconque afin de trouver ensuite la donnée qui lui est associée. Keys renvoie vide si le tableau est vide.

 

*Syntaxe

 

keys(%tableau)

 

*Exemple

 

foreach $cle (keys %tableau)

{

  $donnee = %tableau{$cle};

   print "la donnée $donnee est associée a la clé $cle\n";

}

  

18. last

 

Permet de sortir d'une boucle avant la fin normale de celle-ci comme break en C par exemple.

Un label peut lui être associe afin de continuer l’exécution du programme à un endroit particulier.

 

*Syntaxe

 

last ou last LABEL;

 

19. length

 

Renvoie le nombre de caractères de la chaîne.

 

*Syntaxe

 

length(chaine);

 

20. link

 

Crée un lien en dur entre deux fichiers (équivalent a ln)

 

*Syntaxe

 

link($fichierorigine,$fichierlien);

 

21. lstat

 

Renvoie 13 champs d'informations concernant le lien symbolique et non sur le fichier pointé.

 

*Syntaxe

 

($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,$atime,$mtime,$ctime,

$blksize,$blocks) = lstat($fichier);

 

22. mkdir

 

Crée un répertoire.

 

*Syntaxe

 

mkdir($repertoire,$droit);

 

23. next

 

Permet de passer au traitement de l'élément suivant dans une boucle et d'abandonner le traitement de l'élément en cours.

Un label peut lui être associe afin de continuer l’exécution du programme à un endroit particulier.

 

*Syntaxe

 

next ou next LABEL;

 

24. opendir

 

Ouvre un descripteur de répertoire.

 

*Syntaxe

 

opendir(descripteur,$repertoire);

 

voir closedir, readdir

 

25 pack

 

Convertit une chaîne ou plusieurs chaînes en une structure binaire selon le modèle indiqué. Ce modèle est précisé grâce à une liste de « patron » représentée par des séquences de caractères.

Le résultat est une chaîne de caractères.

*Syntaxe

 

$chaine = pack(“patron”,$chaine1,$chaine2 ... $chainen) ;

 

*Exemple

 

L’exemple utile lorsqu’on traite des résultats de formulaires sur l’internet est la ligne suivante. Elle enchaîne plusieurs opérateurs, elle n’est pas triviale donc ne réinventez pas la roue utilisez là J.  Elle permet de modifier les caractères accentués pour les rendre lisibles sur votre machine en une seule passe.

 

$buffer =~ s/%(..)/pack(“c”,hex($1))/ge;

 

voir aussi la fonction inverse unpack

 

26. pop

 

Retire le dernier élément de la liste (à droite).

La valeur de retour est l'élément supprimé.

 

*Syntaxe

 

pop(@liste)

 

voir aussi push

 

27. push

 

Ajoute un élément ou plusieurs en fin de liste (à droite).

 

*Syntaxe

 

push(@liste,$elemt1,$elemt2,...) <=> @liste=(@liste,$elemt1,$elemt2,...)

 

voir aussi pop

 

28. rand

 

Renvoie une valeur aléatoire comprise entre 0 et 1 si aucune valeur maximale n’est indiquée et entre 0 et la valeur maximale indiquée.

Il est conseillé d’initialiser l’utilisation de rand afin de ne pas avoir des valeurs qui reviennent de manière identiques lors de différents lancement de votre programme. Pour cela utilisez srand avec une expression non triviale.

Par défaut l’initialisation se fera en utilisant la fonction time en argument de srand.

 

*Syntaxe

 

$aleatoire = rand(nombre) ;

 

*exemple

 

$aleatoire = rand 10; # nombre compris entre 0 et 10

 

29. readdir

 

Liste le contenu du répertoire pointé par le descripteur ouvert par opendir.

 

*Syntaxe

 

readdir(descripteur);

 

voir aussi opendir, closedir

  

30. readlink

 

Donne les renseignements sur le fichier lié par la commande symlink (équivalent à ls -l).

 

*Syntaxe

 

readlink($fichier);

 

31. redo

 

Permet de recommencer le traitement de l'élément en cours sans effectuer le traitement après le redo.

Un label peut lui être associe afin de continuer l’exécution du programme à un endroit particulier.

 

*Syntaxe

  

redo ou redo LABEL;

 

32. rename

 

Permet de renommer un fichier sous un autre nom.

 

*Syntaxe

 

rename($fichier,"$autre_nom");

 

33. reverse

 

Inverse le sens de la liste.

 

*Syntaxe

 

@liste_inversee=reverse(@liste)

 

34. rindex

 

Renvoie l'emplacement d'une sous-chaine de caractères dans la chaîne indiquée ou -1 si cette sous-chaine n'existe pas.

Attention les indices commencent à l'indice 0.

La chaîne est parcourue par la droite.

Le paramètre $position permet de faire un recherche à partir d'un indice précis.

 

*Syntaxe

 

rindex($chaine,$sous-chaine);

ou

rindex($chaine,$sous-chaine,$position);

 

35. rmdir

 

Détruit un répertoire

 

*Syntaxe

 

rmdir($repertoire);

 

36. shift

 

Retire le premier élément de la liste (a gauche).

La valeur de retour est l'élément supprimé.

 

*Syntaxe

 

shift(@liste)

 

voir aussi unshift

 

37. sleep

 

Suspend le déroulement du programme durant le laps de temps indiqué.

 

*Syntaxe

 

sleep secondes;

 

38. sort

 

Trie les éléments par ordre alphabétique.

 

*Syntaxe :

   

@liste_trie=sort(@liste)

 

39. split

 

Découpe et range dans une liste les éléments trouvés contenus entre un délimiteur défini.

 

*Syntaxe

 

split(delimiteur,$variable);

 

*Exemple

 

$a = "1:2:3:4::5";

@liste = split(/:/,$a);  -> ("1,"2","3","4","","5")

 

40. sprintf

 

Permet de formater une sortie.

 

*Syntaxe

 

sprintf(format,variables);

 

*Exemple

 

$res = sprintf("Pour la sortie du film %s\n",$nom);

 

41. srand

 

Permet d’initialiser le tirage aléatoire de nombres avec la fonction rand.

Plus l’expression a de chance de donner un résultat différent à chaque lancement de la fonction, plus le tirage sera aléatoire dans le temps.

 

*Syntaxe

 

srand(expression);

 

 

42.  stat

 

Renvoie 13 champs d'informations concernant un fichier.

 

*Syntaxe

 

($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,$atime,$mtime,$ctime,$blksize,

$blocks) = stat($fichier);

 

43. substr

 

Permet d'extraire et de substituer une sous-chaine d'une chaîne.

Si la valeur de $depart est négative, la substitution se fera par la droite (fin de la chaîne).

Si la chaîne résultat est à gauche, le résultat du substr sera stockée dans cette chaîne. Si la chaîne résultat est à droite, cette chaîne devient la chaîne de substitution et remplacera les éléments sélectionnés. La longueur de cette chaîne peut être inférieure ou supérieure à la longueur de substitution, la chaîne résultat sera d'autant plus courte ou plus longue.

 

*Syntaxe

 

$subst = substr($chaine,$depart,$longueur);

ou

substr($chaine,$depart,$longueur)= $rempl;

 

44. symlink

 

Crée un lien symbolique entre deux fichiers (équivalent a ln -s)

 

*Syntaxe

 

symlink($fichierorigine,$fichierlien);

 

45. system

 

Réalise des appels système.

 

*Syntaxe

 

system("appel"); ou system(@liste);

 

La deuxième syntaxe est à privilégier, perl effectuant alors un contrôle sur la validité de la liste. Cela peut éviter des erreurs dramatiques.

 

46. time

 

Renvoie l'heure système qui est le nombre de secondes écoulées depuis le 1er Janvier 1970 à minuit GMT.

Pour obtenir un écart en heure entre deux heures :

($time1 - $time2)/3600

 

*Syntaxe

 

time();

 

47. tr

   

Comme en shell cette commande permet de transformer une chaîne en une autre chaîne ou de modifier des occurrences dans une chaîne.

 

*Syntaxe

   

Voir le man tr

 

*Exemple

 

$name =~ tr/A-Z/a-z/; # Transforme toutes les majuscules en minuscules

$name =~ tr/er/ab/;   # Transforme les e en a et les r en b

 

48. undef

 

Définie la chaîne vide. Avant toutes opérations, une chaîne à cette valeur.

 

49. unlink

 

Détruit un ou plusieurs fichiers.

 

*Syntaxe

  

unlink($fic1,fic2,...);

 

Il est possible de détruire plusieurs fichiers en utilisant une expression :

unlink(<*.o>); détruira tous les fichiers ayant une extension .o

Le < et le > permettent d'inhiber le caractère spécial *

 

50. unshift

 

Ajoute un élément ou plusieurs en début de liste (a gauche).

 

*Syntaxe

 

unshift(@liste,$elemt1,$elemt2,...) <=> @liste=($elemt1,$elemt2,.,@liste)

 

Voir aussi shift

 

51. utime

 

Permet de changer la date des fichiers ou répertoires au niveau de la date de dernière modification et de la date de dernier changement de l'inode.

La valeur de retour de la commande est le nombre de modifications effectuées.

 

*Syntaxe

  

utime($date_modification,$date_inode,$fichier1,$fichier2,..);

 

52. values

 

Renvoie les valeurs contenues dans un tableau associatif.

 

*Syntaxe

 

values(%tab);

 

VIII Autres éléments du langage

 

 

VIII.1 Les paquetages

 

1. Présentation

 

Cette fonctionnalité proposée par Perl n’est pas forcément très utile pour des programmeur de base mais il faut la connaître pour de ne pas mourir idiot.

Faites attention, cela peut arriver n’importe quand et n’importe où. Imaginez, vous faites du quad, ou passez en camion sur les rails de chemin de fer en Amériques ... On sait jamais L.

 

 

Plus sérieusement c’est quoi un paquetage ?

En anglais l’appellation est package. Ceux qui ont déjà programmés en langage orienté objets (Ada, C++ ...) doivent mieux voir de quoi je parle.

Imaginez que vous ayez déjà réalisé(e)s plusieurs programmes perl contenus dans des fichiers différents. Vous êtes en cours de réalisation d’un nouveau et vous vous rendez compte que plusieurs portions de codes pourraient être récupérées dans les fichiers précédents, vous évitant ainsi de devoir réécrire des parties existantes.

Problèmes rien ne dit que les variables sont toutes différentes, que des fonctions n’ont pas le même nom ... Si cela fait 5 lignes ce n’est pas complexe à vérifier mais si c’est beaucoup plus important, la galère.

Par chance vous pouvez alors créer des paquetages. Tout ce qui est dans un paquetage n’a de valeur qu’à l’intérieur de celui-ci. Si vous devez utiliser une variable ou une fonction de ce paquetage il faudra alors la préfixer par le nom du paquetage selon une syntaxe précise.

 

Pour bien se représenter la chose imaginez que vous habitez une superbe maison dans un superbe ... lotissement comme l’un des suivants :

 

 

Vous invitez chez vous des amis, comment vont ils retrouver votre maison ?

äFacile c’est une maison avec un étage et un jardin de 2 mètres carré.

âEuh t’es gentil il y en a au moins 30 milles comme ça. Elles se ressemblent toutes, à quelque chose prêt.

äElle a le numéro 44

âSuper une maison avec un étage, 2 mètres carré d’herbe qui porte le numéro 44. Ca va être facile à trouver il y en a au moins 500 qui ont cette caractéristique.

Donnes moi une indication qui me permettra de la trouver sans possibilité d’erreur !

äElle est rue de la solitude.

âEh bien voilà c’est mieux ý rue de la solitude : : maison 44.

Bon reste plus qu’à trouver cette ghi¦W de rue de la solitude. Non vraiment chouette le coin je t’assure j’aime beaucoup !

 

Pour replacer le tout dans le contexte des paquetages, la maison 44 serait la variable ou la fonction et le nom de la rue le paquetage. Pour identifier la maison, vous la préfixez par le nom de la rue. Pour identifier la variable, vous la préfixez par le nom du paquetage.

Un autre exemple pris pour la compréhension est celui des fichiers et des répertoires. Vous pouvez avoir deux fichiers portant le même nom dans deux répertoires différents. Pour l’identifier de manière sure vous direz répertoire/fichier. Le fichier est la variable, le répertoire le paquetage seul le séparateur change c’est un :: et non un / (sous unix).

 

2. Syntaxe

 

Le mot clé a utiliser est package.

 

package  nom;

variables, fonctions et actions de ce paquetage

 

3. Exemples

 

Exemple avec une variable identique.

 

package Programme1;

$chaine = "Frédéric";

 

package Programme2;

$chaine = "Jacquenod";

 

package Main;

$a = $Programme1::chaine;

$b = $Programme2::chaine;

print "$a $b\n";

 

Tout se qui se situe entre deux opérateurs package fait partie du premier package.

 

La syntaxe avec des fonctions est un peu différente.

Prenons l’exemple de deux paquetages Programme1 et Programme2 ayant chacune une fonction multiplication à laquelle on doit passer une valeur à multiplier. La première multiplie par 2 et la deuxième par 3.

 

L’appel dans le paquetage principal Main se fera de la façon suivante :

 

$a = Programme1->multiplication(5);       # vaut 10

$b = Programme2->multiplication(5);       # vaut 15

 

Nous le verrons complètement avec les exemples durant le cours.

 

VIII.2 Les modules

 

1. Présentation

 

Vous avez un certains nombres de fonctions, de déclarations, ..., que vous réutilisez souvent dans vos programmes.

Des fonctions peuvent intéresser d’autres programmeurs Perl, leurs évitant ainsi de devoir réécrire et de récréer des morceaux de codes existants. Même chose pour vous, si vous devez utiliser une fonction calculant des cosinus, travaillant sur des bases de données, autant réutiliser des fonctions déjà crée et disponible plutôt que perdre du temps à réinventer la roue.

Ces fichiers ont pour nom : module.

Un module est un ensemble de fonctions, de procédures ayant un rapport entre elles (fonctions mathématiques, accès à des bases de données, gestion des sockets pour les accès réseau ...). Elles sont contenues dans un paquetage. Le nom du fichier contenant le tout possède l’extension .pm. Ce nom de fichier

aura le nom du paquetage.

Le fichier contenant le module se termine par 1; .

La distribution perl que vous installez possède déjà un grand nombre de modules qui se situe notamment dans les répertoires lib, ext ... de votre installation.

Rien ne vous empêche d’en installer autre part, il faudra juste le signifier

lors de l’appel dans votre programme perl.

Vous trouverez un grand nombre de modules sur le site du CPAN.

 

 

Le répertoire by-category est rangé par type de modules. Modules orientés vers le web, vers la sécurité ... Récupérez le module voulu, installez le dans un répertoire visible de Perl (voir liste @INC) et vous pourrez ensuite l’utiliser.

 

 

 

2. Syntaxe

 

*Exemple 

 

Le module integer se situe dans un fichier nommé integer.pm

 

package integer;

 

sub import {

    $^H |= 1;

}

 

sub unimport {

    $^H &= ~1;

}

 

1;

 

 

Le fait de déclarer un paquetage lors de la création d’un module permet d’éviter les effets de port lorsque le module sera importé dans le programme (Voir les paquetages).

 

3. Utilisation d’un module

 

Lorsque vous désirez utiliser un module, vous devez le signifier au départ dans votre programme perl au moyen des mots clés require ou use.

Le mot clé require charge le module à l’exécution de votre programme tandis que le mot clé use le charge dès la compilation. Les instructions suivantes sont équivalentes.

 

use Nom;             begin {

                  Û     require Nom;

                           import Nom;

                           }

 

Il est donc préférable d’utiliser le mot clé use si le module doit être chargé. Par contre si le module ne doit être chargé que sous certaines conditions, il n’est pas nécessaire de le charger dès la compilation, préférez alors require et import pour le chargement.

 

Les répertoires par défaut dans lesquels se situent les modules sont contenus dans la variable @INC. Si un module à charger s’y trouve, il suffit de mettre la ligne suivante :

 

require Nom;                 # Nom est le nom du module et du fichier qui a

                                    # l’extension .pm se trouvant dans un des   

                                    # répertoire contenu dans la variable @INC

ou

 

require ”Nom.pm”;        # Nom.pm est le nom du fichier se trouvant dans un des   

                                    # répertoire contenu dans la variable @INC

 

ou

 

use Nom;

 

Si le module est mis dans un sous-répertoire de l’arborescence indiquée dans @INC. Ce module contiendra le paquetage Rep::Nom (package Rep::Nom ;).

L’appel dans votre programme devra le spécifier.

 

require Rep::Nom;         # Nom est le nom du module et du fichier qui a

                                    # l’extension .pm se trouvant dans 

                                    # un sous-répertoire d’un des  répertoires contenu

                                    # dans la variable @INC

 

ou

 

require ”Rep/Nom.pm”;          # Nom.pm est le nom du fichier se trouvant dans 

                                    # un sous-répertoire d’un des  répertoires contenu

                                    # dans la variable @INC

 

ou

 

use Rep::Nom;

 

Si le module est dans un autre répertoire non défini dans la liste @INC, indiquez le chemin absolu.

 

use ”/usr/local/module-perl/Rep/Nom.pm ”;