[PDF] Cours langage Perl : les fichiers, les expressions régulières et les fonctions | Cours informatique

Introduction à Perl

Perl (Practical Extraction and Reporting Language) est un langage de programmation généraliste créé en 1986 par Larry Wall, à l'origine pour la manipulation de texte. Il est maintenant utilisé dans une large gamme de tâches incluant l'administration système, le développement web, la programmation réseau, le développement d'interfaces graphiques. C'est un langage censé être pratique (facile à utiliser, efficace et complet) plutôt que beau (bref, élégant et minimal). Ses principales caractéristiques sont sa simplicité d'utilisation, son support à la fois de la programmation procédurale et objet, ses capacités intégrées de manipulation de texte ainsi qu'une impressionnante collection de modules.

I. Syntaxe de Perl : les bases

La syntaxe de Perl est très largement inspirée de celle du C et de celle du Shell : quelqu'un habitué à programmer en C s'adaptera vite au Perl. Cependant, comme vous le verrez, Perl apporte beaucoup d'autres choses.

Voici des choses communes à Perl et au C :

● les instructions sont délimitées par des points-virgules (;) et groupées par des accolades ({ .... })

● les opérateurs sont les mêmes : affectation (=, +=, ...), comparaison (<, <=, ==, ...), arithmétiques (+, -, /, *, %), logiques (&&, ||, !) manipulation de bits (&, |, ^, ~)

● les structures de contrôles suivent la même syntaxe : if(), switch(), while(), for()

● les noms de fonctions sont largement inspirés de celles du C ; un certain nombre sont même identiques Les principales différences tiennent au fait que Perl n'est pas orienté programmation système mais programmation haut-niveau. C'est pourquoi :

● il n'est pas obligatoire de déclarer les variables

● la notion de pointeur n'existe pas : c'est la notion de référence qui est utilisée (comme en C++, Java, VB ...), ● les chaînes de caractères et les tableaux sont manipulables bien plus facilement qu'en C,

● les parenthèses ne sont pas obligatoires : on les met seulement lorsqu'on ne peut pas faire autrement (pour des raisons de priorité)

Un fichier source Perl (ou script Perl) porte généralement l'extension .pl et devrait débuter par le shebang #!/usr/bin/perl. Pour lancer un tel script, on a deux options :

● perl monscript.pl

● ./monscript.pl à condition d'être sous Unix et que le fichier ait été rendu exécutable (chmod 755 monscript.pl)

1. Déclaration et portée des variables

Les noms de variables débutent par un $, un @ ou un % suivant qu'on désigne un scalaire, un tableau dans son ensemble ou un tableau associatif dans son ensemble (voir les sections suivantes).

Le nom de variable en lui-même doit essentiellement suivre les mêmes règles qu'en C. Perl fait aussi la différence entre les majuscules et les minuscules.

En Perl, la coutume veut qu'on écrive ses noms de variables en minuscules, les mots étant séparés par un underscore _. Enfin, il faut savoir que Perl stocke ses identificateurs dans un espace de noms séparé, suivant leur famille (variable scalaire, liste, table de hachage, fonction...) : il n'y a donc aucun problème (du point de vue de Perl, en tout cas !) à ce qu'une variable scalaire s'appelle $var alors qu'il existe un tableau nommé @var et une fonction nommée &var dans le même programme.

Déclaration et portée des variables

Perl possède plusieurs particularités au sujet des variables : ● il n'est pas nécessaire de déclarer les variables ● par défaut, toutes les variables sont globales.

Cependant, il est recommandé de déclarer ses variables à l'aide de my. La fonction my déclare une ou plusieurs variables comme étant locales au bloc englobant. Par exemple, my $n déclare une variable n et my ($i, $j) = (2,3) déclare

et initialise deux variables i et j.

En outre, il est recommandé d'exiger que Perl vérifie la déclaration des variables en utilisant le pragma use strict;. Tant qu'à faire, autant ajouter aussi le pragma use warnings; qui permet d'avoir des avertissements lorsque Perl rencontre des instructions suspectes.

Finalement, un programme Perl devrait toujours débuter par : #!/usr/bin/perl

use strict; use warnings;

Initialisation des variables

Tant qu'elle n'a pas été initialisée, une variable vaut undef. Il est possible de le savoir en utilisant la fonction defined. Le code suivant illustre cela :

my $n;

if( defined $n ){

print 'n est défini'; }else{

print 'n n\'est pas défini'; }

2. Données scalaires

Les scalaires sont les types de données les plus simples de Perl : ce sont essentiellement les nombres et les chaînes de caractères.

Les nombres

Pour Perl, tous les nombres sont des nombres à virgule flottante en double précision (double en C).

Les opérateurs sont identiques à ceux du C mais Perl dispose en plus d'un opérateur pour la puissance : **. Ainsi, 2**4 vaut 16.

les chaînes de caractères

Les chaînes peuvent être spécifiées par un littéral entre guillemets simples (apostrophes ') ou guillemets doubles (guillemets "). La différence entre les deux délimiteurs sera expliquée en détail au paragraphe 5.

Puisque Perl ne distingue pas nombres et chaînes, il fournit des opérateurs de comparaison spécifiques aux chaînes : eq (égalité) ne (différence)

lt (inférieur) gt (supérieur) le (inférieur ou égal) ge (supérieur ou égal) En plus, Perl dispose des deux opérateurs x et . :

● . permet de concaténer deux chaînes de caractères ; par exemple, "bonjour " . "vous !" vaut "bonjour vous !"

● x permet de répéter un certain nombre de fois une chaîne ; ainsi "bla " x 3 vaut "bla bla bla " Fonctions utiles

La plus utile des fonctions est sans doute print, qui permet d'afficher un texte à l'écran. Par exemple, print "x vaut ", $x, ".\n"; affiche « x vaut 5 » suivi d'un retour à la ligne.

conversions chaînes<->nombres

Perl effectue automatiquement une conversion entre chaîne et nombre lorsque c'est nécessaire.

Par exemple "123" * 4 sera converti en 123 * 4, de même que "123 nous irons au bois" * 4. En revanche, "nous irons au bois" * 4 sera converti en 0 * 4.

Un autre exemple : "x vaut " . 5 sera converti en "x vaut " . "5".

Les conversions suspectes sont indiquées par Perl si on a pris la précaution de le lancer avec l'option -w (warnings) ou de préciser use warnings; en tête du script.

3. Listes et tableaux

Une liste est un ensemble ordonné de scalaires. Un tableau est une variable contenant une liste. Les deux termes sont souvent utilisés indifféremment mais, en fait, la liste représente les données et le tableau la variable.

Une liste contient des éléments numérotés à partir de 0, comme en C. Ces éléments sont donc des scalaires mais rien n'oblige qu'ils soient tous des nombres ou tous des chaînes (même si c'est généralement le cas !).

Comme en C, on accède aux éléments d'un tableau en utilisant l'opérateur [ ]. Par exemple, $arbres[0] = "pin"; ou $arbres[1] = "chêne";.

Une liste n'est pas obligatoirement contenue dans un tableau. Ainsi, (1, 3, 5, 7, 9) est une liste de 5 éléments, ("pin", "chêne") est une liste de 2 éléments et () est une liste vide.

On peut affecter une liste à un tableau de la façon suivante : @arbres = ("pin", "chêne", "arbousier");. Notez bien qu'ici, @arbres est utilisé pour désigner le tableau dans son ensemble et non un élément isolé.

Il est également possible d'affecter un tableau à une liste de la façon suivante :($arbre1, $arbre2) = @arbres;. Ici, même si le tableau @arbres contient plus de deux éléments, seuls les deux premiers sont affectés aux variables $arbre1 et $arbre2. Cette pratique est très courante, notamment au début du code des fonctions pour en récupérer les arguments.

Fonctions utiles

Les fonctions suivantes sont tellement importantes qu'elles sont détaillées dans cette section. qw

Il est fréquent en Perl d'utiliser des listes de mots simples. Le raccourci qw (quoted words) facilite leur création en permettant d'éviter la saisie des guillemets et des virgules. Par exemple @arbres = qw( pin chêne arbousier ); est identique à @arbres = ("pin", "chêne", "arbousier");. On a utilisé des parenthèses comme délimiteurs mais n'importe quel caractère de ponctuation peut faire l'affaire : qw{ ... } , qw! ... ! , etc.

push/pop

Ces fonctions permettent de travailler sur l'extrémité droite d'une liste pour ajouter (push) ou supprimer (pop) des éléments. Cela évite l'accès au tableau à l'aide d'indices. Par exemple, push @arbres, "acacia" ajoute « acacia » au tableau @arbre en dernière position. A l'inverse, $un_arbre = pop @arbres retire le dernier élément du tableau @arbres et stocke ce qui a été retiré dans le scalaire $un_arbre.

shift/unshift

A l'inverse des fonctions précédentes, shift et unshift permettent de travailler sur l'extrémité gauche d'une liste pour ajouter (unshift) ou supprimer (shift) des éléments. Par exemple, unshift @arbres, "acacia" ajoute « acacia » au tableau @arbre en première position. A l'inverse, $un_arbre = shift @arbres retire le premier élément du tableau @arbres et stocke ce qui a été retiré dans le scalaire $un_arbre.

Itérer sur un tableau : foreach

Pour itérer sur une liste, on peut toujours utiliser la syntaxe « à la C » : for( $i=0; $i<=$#arbres; $i++ ){

print $arbres[$i], "\n"; }

Mais Perl propose une syntaxe plus claire, plus concise et qui évite le recours aux indices : foreach $arbre (@arbres){

print $arbre, "\n"; # affiche les arbres, chacun sur une ligne }

Voici les différences fondamentales entre les deux syntaxes :

• dans un cas, la variable de contrôle est un indice ; dans l'autre, un élément • avec foreach, on est sûr d'atteindre tous les éléments, ni plus, ni moins ! • la seconde syntaxe est plus rapide à taper et plus lisible

1. $arbre (la variable de contrôle) n'est pas une copie d'un élément de la liste mais bien l'élément lui-même. Par conséquent, si vous le modifiez dans la boucle, cela modifie la liste !

2. $arbre se comporte comme une variable locale à la boucle : si vous utilisiez avant la boucle une autre variable $arbre, celle-ci ne sera absolument pas affectée par ce qui se sera passé dans la boucle.

Voici un autre point important : lorsque vous ne spécifiez pas de variable de contrôle au début de la boucle foreach, Perl utilise sa variable par défaut préférée, $_. A part son nom bizarre, elle ressemble à n'importe quelle variable ! foreach (@arbres){

print $_, "\n"; # affiche les arbres, chacun sur une ligne }

Perl utilise cette variable par défaut dans bien d'autres cas lorsqu'on ne lui précise pas d'employer une autre variable ou valeur. C'est entre autres le cas de print :

foreach (@arbres){

print ; # affiche les arbres, tous sur la même ligne }

Contexte de scalaire et contexte de liste

En Perl, une expression donnée peut signifier différentes choses selon le contexte dans lequel elle apparaît. Le contexte fait référence à l'endroit ou figure cette expression. Lorsque Perl analyse l'expression, il attend toujours un contexte de scalaire ou de liste. Par exemple :

42 + quelque-chose # quelque chose doit être un scalaire pop quelque-chose # quelque-chose doit être une liste

Si quelque-chose est exactement la même séquence de caractères, dans un cas il pourra donner une valeur scalaire unique et, dans l'autre, une liste (éventuellement vide ou constituée d'un seul élément).

Par exemple, le nom d'un tableau utilisé dans un contexte de liste renvoie la liste des éléments du tableau (bien sûr !). En revanche, dans un contexte de scalaire, il renvoie le nombre d'éléments du tableau. Par exemple :

@arbres = qw( pin chêne arbousier );

pop @arbres; # contexte de liste : ôte le dernier élément du tableau $nb_elements = @arbres; # contexte de scalaire : renvoie le nombre d'éléments (3)

4. Tables de hachage

Concepts et syntaxe

Une table de hachage (hash table) est un tableau de scalaires dans lequel les « indices » ne sont pas des nombres mais des chaînes : on appelle ces chaînes des clés (keys) parce qu'elles sont uniques dans la table.

Dans une table de hachage, il n'y a pas vraiment d'ordre prédéfini : les éléments de la table sont « en vrac ». Il n'y a donc ni « premier » élément, ni « dernier » élément.

Contrairement aux tableaux (indexés), on accède à un élément d'une table en utilisant les accolades { }. Par exemple, $jours{"lundi"} = "monday". Cela est nécessaire pour que Perl puisse distinguer un tableau indexé d'une table de hachage.

Pour faire référence à une table de hachage dans son ensemble, on utilise le préfixe %. Ainsi, la table de hachage précédente est %jours. Il est possible d'affecter en un bloc une table de hachage de la façon suivante :

%jours = (

"lundi"=> "monday", "mardi"=>"tuesday", "mercredi"=>"wednesday" );

Les retours à la ligne ne sont pas obligatoires mais facilitent la lecture. Fonctions utiles

keys/values

Les fonctions keys et values retournent une liste formée respectivement de l'ensemble des clés et des valeurs d'une table de hachage. Si la table ne contient aucun élément, ces fonction retournent une liste vide. Par exemple :

my %jours = ( lundi=> "monday", mardi=>"tuesday", mercredi=>"wednesday" ); my @cles = keys %jours; # @cles vaut ('lundi', 'mardi', 'mercredi')

Notez bien, dans ce cas, que :

• les éléments de la liste @cles correspondent terme à terme à ceux de la liste @valeurs : si 'mercredi' est la dernière clé, alors 'wednesday' est la dernière valeur ;

• les valeurs de la table qui apparaissent plusieurs fois sont également répétées dans la liste fournie par values. exists/delete

La fonction exists permet de savoir si une clé existe dans une table de hachage. La fonction delete, quant à elle, permet d'y supprimer la clé indiquée (ainsi que la valeur correspondante). Voici un exemple dans lequel on vérifie que la clé voulue existe, avant de la supprimer :

my %jours = ( lundi=> "monday", mardi=>"tuesday", mercredi=>"wednesday" ); if( exists $jours{'lundi'} ){

# ok, lundi est bien une clé de la table # supprimons-la :

delete $jours{'lundi'}; }

Itérer sur une table de hachage foreach

Il est toujours possible d'itérer sur une table de hachage à l'aide de foreach après en avoir extrait les clés : foreach $cle (keys %jours){

print "cle=$cle, valeur=$jours{$cle}\n"; }

each

Mais Perl propose la fonction each qui permet de faire la même chose sans le recours à la fonction keys. A chaque évaluation de la fonction each sur la même table de hachage, la paire clé/valeur suivante est renvoyée, jusqu'à ce que tous les éléments aient été examinés. Lorsqu'il n'y a plus d'élément, each retourne une liste vide. On l'utilise typiquement dans une boucle while, comme ceci :

while( ($cle,$valeur) = each %jours ){ print "cle=$cle, valeur=$valeur\n"; }

5. Spécial...

Booléens et valeurs « nulles »

Perl ne connaît pas le type « booléen » mais, dans une instruction if ou while par exemple, il a besoin de décider si la valeur d'une expression est vraie ou fausse. Pour cela, il utilise les règles suivantes :

• si la valeur est un nombre, alors 0 signifie faux et tous les autres nombres signifient vrai

• si la valeur est une chaîne, la chaîne vide ('') signifie faux et toutes les autres chaînes signifient vrai • undef signifie faux

Il y a juste un petit problème : quelle est la valeur logique de '0' ? Puisque '0' est la même valeur scalaire que le nombre 0, Perl doit les traiter comme identiques. Cela signifie que '0' signifie également faux.

Par conséquent, les seules chaînes qui valent faux sont en fait '' et '0'. Histoires de quotes

Pour délimiter les littéraux chaînes, on a rencontré les guillemets simples (apostrophes ') ou guillemets doubles (guillemets "). Il existe deux différences entre les deux : l'interprétation des séquences d'échappement et l'interpolation. Interpoler une variable consiste à la remplacer par sa valeur. Le tableau suivant résume la situation :

interpolation séquences d'échappement ' ... ' non \'_\\ signifie_signifie '_\ " ... " _{oui \" signifie "}

\$ signifie $

\@ signifie @

\n signifie « retour à la ligne » \r signifie « retour chariot » \t signifie « tabulation »

...

Dans une chaîne délimitée par des guillemets doubles, les variables sont remplacées par leur « valeur » : • les chaînes sont remplacées par leur valeur

• les nombres sont remplacés par leur valeur (en utilisant un format par défaut)

• les tableaux (indexés) sont remplacés par la liste de leurs éléments, séparés par un espace • les variables non initialisées (undef) sont remplacées par une chaîne vide

• les tables de hachage ne sont pas interpolées ! Par exemple :

my @arbres = ("pin", "chêne", "arbousier"); my $n = @arbres;

print "J'ai $n arbres :\n";

print "Voici leurs noms : @arbres\n";

print "Mon arbre préféré est le $arbre[1]\n";

Faites attention si vous utilisez l'arobase @ pour saisir une adresse e-mail entre guillemets doubles ! Il vaudrait peut-être mieux la saisir entre guillemets simples.

Plus de quotes

Perl fournit des moyens alternatifs pour écrire des littéraux chaînes qui peuvent être utiles pour diminuer le nombre de virgules et de guillemets à taper ainsi que pour éviter d'« échapper » certains caractères comme les \. En fait, nous avons déjà rencontré qw/ / qui sert à délimiter une liste de mots. Mais il y en a d'autres, listés dans le tableau suivant :

habituellement générique signification interpolation ?

' ... ' q/ ... / littéral non

" ... " qq/ ... / _{littéral oui}

` ... ` qx/ ... / _{commande système oui}

( ... ) qw/ ... / liste de mots non

Il en existe encore d'autres, liés aux expressions régulières, que nous rencontrerons plus loin.

II. D'autres éléments importants

1. Fonctions définies par l'utilisateur

On peut définir une fonction n'importe où dans le code en utilisant la syntaxe suivante : sub ma_fonction {

# corps de la fonction }

Vous pouvez remarquer deux choses :

• on ne précise pas les arguments de la fonction,

• cette fonction peut ou non renvoyer une valeur (comme en C) mais on ne peut pas le deviner à la lecture du « prototype ».

Notez également qu'une fonction a un accès total aux variables du programmes (elles sont globales). Appeler une fonction

&ma_fonction. Valeur de retour

Une fonction définie par l'utilisateur peut renvoyer une valeur en utilisant l'opérateur return comme en C. Arguments

Les fonctions définies par l'utilisateur peuvent attendre des arguments. Plus exactement, une fonction peut attendre une

liste en argument (sans la déclarer préalablement). La fonction reçoit cette liste dans une variable tableau spéciale

nommée @_ pour toute la durée d'exécution de la fonction.

Le premier argument de la fonction est donc stocké dans $_[1], le deuxième dans $_[2], etc. Attention, le tableau @_ n'a rien à voir avec la variable par défaut $_ (si ce n'est que leurs noms se ressemblent).

Voici l'exemple d'une fonction max, qui attend deux arguments et renvoie le plus grand des deux : sub max {

if( $_[0]>$_[1] ){ # si le 1er argument est plus grand que le 2ème return $_[0]; # renvoyer le 1er

}else{

return $_[1]; # sinon renvoyer le 2ème }

}

$m = &max( 5, 7 ); # exemple d'appel

Le code d'une fonction est généralement plus facile à lire si elle ne manipulent pas des arguments aux noms barbares comme $_[0] ! Il est donc coutume d'affecter la liste d'arguments @_ à une liste de variables plus convenables, comme dans l'exemple suivant :

sub max {

my( $a, $b ) = @_; # affectation des arg. à des var. locales (+ lisible) if( $a>$b ){ # si le 1er argument est plus grand que le 2ème

return $a; # renvoyer le 1er }else{

return $b; # sinon renvoyer le 2ème }

}

Nombre variable d'arguments

Une fonction définie par l'utilisateur peut facilement accepter un nombre variable d'arguments. Par exemple, la fonction max définie ci-dessus calcule le maximum de 2 éléments mais pourquoi ne pourrait-elle pas calculer le maximum d'un nombre quelconque d'arguments ? Ce n'est pas techniquement un problème puisque les arguments sont reçus dans une liste (qui peut être vide, constituée d'un seul élément ou de beaucoup plus). On procède souvent ainsi :

sub max {

my($max_actuel) = shift @_; # on enlève le 1er argument : c'est notre max # (jusqu'à présent)

foreach( @_ ){ # pour chaque argument (sauf le 1er, maintenant) if( $_>$max_actuel ){ # si l'argument est plus grand que notre max temp

$max_actuel = $_; # alors il devient notre nouveau max }

}

return $max_actuel; # on retourne la plus grande valeur rencontrée }

Omission du & dans l'appel de fonction On peut omettre le & lorsqu'on appelle une fonction :

• si la fonction a été définie avant l'appel

• ou si vous passez entre parenthèses une liste d'arguments (éventuellement vide) lors de l'appel • et si le nom de fonction que vous avez choisi n'est pas déjà le nom d'une fonction interne de Perl ! En résumé : utilisez toujours & pour appeler une fonction jusqu'à ce que vous soyez vraiment sûr de vous !

2. Modules

Perl autorise l'écriture de modules qui peuvent être assemblés pour former une application. Cette fonctionnalité a permis le développement de nombreuses contributions : des modules ont été développés pour interfacer TCP, CGI, FTP... c’est

une des raisons du succès de Perl. Trouver des modules

Les modules existent sous deux formes : ceux livrés avec Perl et ceux disponibles sur CPAN ( Comprehensive Perl

Archive Network). Pour trouver des modules qui ne sont pas fournis avec Perl, allez sur le site de CPAN et effectuez une

recherche. Vous obtiendrez la liste des modules qui correspondent à vos critères et pourrez accéder à une description détaillée pour chacun d'entre eux.

Pour vérifier si un module est déjà installé, vous pouvez essayer de lire sa documentation. Par exemple, pour lire la documentation du module CGI.pm (fourni avec Perl), tapez dans un shell :

$ perldoc CGI Installer des modules

Pour installer un module, le plus simple est d'utiliser le module CPAN.pm en l'appelant depuis la ligne de commande sous la forme suivante :

$ perl -MCPAN -e shell

Si c'est la première fois que vous utilisez ce module, vous devrez en effectuer la configuration (partiellement automatisée) puis vous pourrez installer d'autres modules, un peu de la même façon qu'avec yum pour installer des packages rpm.

Inclure du code : require

La forme la plus simple de l’écriture modulaire est l’inclusion de code, autorisée en Perl par la fonction require suivie d'un nom de fichier contenant le code à inclure. Il s’agit d’une fonctionnalité équivalente au require du PHP.

On regroupe en général les inclusions en début de programme : #!/usr/bin/perl

require "cgi-lib.pl"; # Inclusion de la bibliothèque gérant l’interface CGI

Les modules Perl écrits ainsi sont souvent un peu anciens et proposent des interfaces rudimentaires. En revanche, cette technique est simple à utiliser pour ses propres besoins.

Notez que Perl cherche les modules à inclure dans le répertoire courant et dans les répertoires cités dans le tableau @INC.

Utiliser des packages : use

Un package Perl est généralement fourni sous la forme d'un fichier portant l'extension .pm. Il s'agit d'une forme de module plus évoluée : en effet, un package possède l'avantage d'éviter les collisions de nom en protégeant les variables et les fonctions qu'il exporte dans un espace de nom qui lui est propre. De plus, il peut exister des dépendances entre les

packages.

Pour utiliser un package, il suffit de le déclarer en tête du fichier : #!/usr/bin/perl

use File::Basename; # utilisation du package File::Basename

Il devient alors possible d'utiliser toutes les fonctions et variables qu'il exporte, comme s'il s'agissait de fonctions et de variables fournies par Perl. Par exemple, le module File::Basename fournit une fonction basename qui permet d'obtenir le nom de base d'un fichier. On peut donc écrire :

my $nom = "/usr/bin/perl";

my $nombase = basename $nom; # donne 'perl'

Vous vous dites peut-être que ce n'est pas la peine d'utiliser un module pour faire cela ! Sachez seulement que ce module prend en charge les différences dans les noms de chemins entre les plateformes, entre autres subtilités.

En lisant le code d'autres personnes, vous verrez souvent des choses comme : use File::Basename qw/ basename /;

Cela signifie qu'on n'importe depuis ce module que la fonction basename et non toutes les autres. Cela ne veut pas dire qu'on ne peut pas les utiliser : on pourra toujours appeler une fonction de ce module en indiquant son nom complet, par exemple :

my $dir = File::Basename::dirname $nom; # donne '/usr/bin/' On aura l'occasion d'utiliser, plus loin dans ce cours, les modules CGI et DBI.

3. Structures de contrôle idiomatiques

Perl propose des structures alternatives à if et while ; ce sont respectivement unless et until. Elles fonctionnent exactement de la même façon que leurs sœurs mais le test est inversé.

Ainsi, les exemples suivants sont équivalents : unless( $n==0 ){

print "n est différent de 0"; }

correspond à

if( $n!=0 ){

print "n est différent de 0"; } et $n = 5; until( $n==0 ){ print "n vaut $n\n"; $n--; } correspond à $n = 5; while( $n!=0 ){ print "n vaut $n\n"; $n--; }

Sachez également qu'il n'existe pas de switch en Perl. A la place, on utilisera quelque chose comme : if( !defined $n ){

print "n n'est pas défini\n"; } elsif( $n==0 ){

print "n vaut 0\n"; } elsif( $n>0 ){

print "n est positif\n"; } else {

print "n est négatif\n"; }

Modificateurs d'expression

Pour une notation plus compacte, une expression peut être suivie d'un modificateur de contrôle. Par exemple, le modificateur if fonctionne de manière analogue à un bloc if :

print "$n est négatif\n" if( $n<0 ); Ce code est équivalent à :

if( $n<0 ){

print "$n est négatif\n" ; }

sauf qu'il est beaucoup plus court !

Il existe également les modificateurs unless, until, while et foreach qui fonctionnent comme on peut l'espérer. Ces formes plus courtes se lisent quasiment comme en langue naturelle. Certains aiment à les présenter de la façon suivante :

print "n vaut $n\n" if( defined $n );

Mais ne perdez pas de vue que, bien qu'il soit placé après le print, c'est le if( ) qui est évalué en premier ! Opérateurs logiques comme structures de contrôle

Les opérateurs logiques && et || fonctionnent comme en langage C sauf que Perl est systématiquement paresseux lors de l'évaluation :

• lorsque le côté gauche du && vaut faux, Perl n'évalue pas le côté droit et renvoie faux directement • lorsque le côté gauche d'un || vaut vrai, Perl n'évalue pas le côté droit et renvoie vrai directement.

Mais contrairement à ce qui se passe en C, la valeur renvoyée par un opérateur logique est la dernière partie évaluée, et non une valeur booléenne 0 ou 1. En ce qui concerne le test logique, cela revient au même mais cette valeur de retour

est très utile. On l'utilise souvent de la façon suivante : $jour = "lindi";

$jour_en_anglais = $jours{ $jour } || 'unknown day';

Les opérateurs && et || possèdent des équivalents notés and et or. La seule différence est que ces derniers ont la priorité la plus faible possible (en tant qu'opérateurs). Ils sont fréquemment utilisés pour écrire des phrases du type : open FICHIER, $nom_fichier

or die "Impossible d'ouvrir le fichier !\n"; Cela signifie « ouvre ce fichier... ou meurt ! » puisque :

• si l'ouverture réussit, open renvoie vrai et, puisque l'expression conditionnelle est forcément vraie, le or est terminée (et donc le message n'est pas affiché)

• si l'ouverture échoue, la valeur faux renvoyée par open amène le or à évaluer la partie de droite, qui termine le programme avec un message d'erreur.

4. Entrées/sorties

Lecture et écriture sur STDIN et STDOUT

L'entrée standard est représentée en Perl par le descripteur STDIN et la sortie standard par STDOUT. Comme vous le savez sans doute, il s'agit généralement du clavier et de l'écran.

La lecture sur l'entrée standard se fait à l'aide de l'opérateur diamant et l'écriture simplement avec print, qui écrit par défaut sur STDOUT. Typiquement, cela ressemble à :

my $ligne = <STDIN>; # lire une ligne sur l'entrée standard

chomp( $ligne ); # la débarrasser de son \n final

print "Je viens de lire $ligne\n"; # affichage sur STDOUT de ce qu'on vient de lire ou bien, de façon plus idiomatique :

chomp( $ligne=<STDIN> ); # lecture et nettoyage d'une ligne

print "Je viens de lire $ligne\n"; # affichage sur STDOUT de ce qu'on vient de lire Lecture et écriture sur des fichiers

Ce qu'on vient de voir permet de lire et d'écrire, de la même façon, avec de « vrais » fichiers. Il suffit d'obtenir un descripteur de fichier en ouvrant le fichier puis d'utiliser l'opérateur <> pour lire et print pour écrire.

ouverture d'un fichier

Ouvrir un fichier permet d'obtenir, de la part du système, un accès en lecture et/ou en écriture. On ouvre un fichier en utilisant l'opérateur open. et on obtient un descripteur de fichier à utiliser pour toutes les opérations suivantes sur ce fichier. Voici quelques exemples d'ouverture :

open CONFIG, "< /etc/yum.conf"; # en lecture

open TEMP, "> fichier.tmp"; # en écriture (crée le fichier s'il

# n'existe pas ; sinon, écrase l'ancien) open JOURNAL,">> /var/log/monappli.log" # en ajout (crée le fichier s'il

# n'existe pas)

open DONNEES,"+< appli-data"; # en lecture/écriture (ne crée pas le # fichier s'il n'existe pas)

Les descripteurs de fichiers récupérés sont respectivement CONFIG, TEMP, JOURNAL et DONNEES. Vous pouvez remarquer qu'ils sont notés en majuscules : ce n'est pas une obligation mais une habitude raisonnable.

Bien entendu, avant de poursuivre, il vaut mieux s'assurer qu'on a bien obtenu ce qu'on voulait en procédant comme on l'a vu plus haut :

open CONFIG, "< /etc/yum.conf"

or die "Impossible d'ouvrir yum.conf : $!\n"; # problème d'ouverture

Notez que la variable spéciale $! contient le dernier message d'erreur survenu (par exemple, « fichier non trouvé » ou « autorisation refusée »). die affiche un message d'erreur en précisant le nom du programme ainsi que la ligne incriminée puis arrête immédiatement le programme.

Si on veut être moins violent, on peut juste afficher un avertissement avec la fonction warn : cela fait la même chose que die mais n'arrête pas le programme.

écriture dans un fichier

Une fois un fichier ouvert en écriture, on peut écrire dedans à l'aide de la fonction print. Il suffit de passer en 1er

argument le descripteur du fichier dans lequel on veut écrire : print JOURNAL "$heure -- mise à jour terminée.\n";

Remarquez qu'il n'y a pas de virgule après le nom du descripteur de fichier (mais ne me demandez pas pourquoi !). On peut également utiliser printf (qui fonctionne comme en C) de la façon suivante :

printf JOURNAL "le %s à %s : mise à jour terminée.\n", $date, $heure;

lecture dans un fichier

On lit dans un fichier à l'aide de l'opérateur diamant < ... >. Dans un contexte de scalaire, l'opérateur lit une ligne du fichier. Dans un contexte de liste, l'opérateur lit toutes les lignes du fichier : cela peut, notamment pour un gros fichier, dégrader considérablement les performances, c'est pourquoi il vaut mieux éviter cette technique (appelée slurping). Voici deux exemples :

chomp( $ligne = <CONFIG> ); # lit une ligne du fichier et la débarrasse de son "\n" chomp( @lignes = <CONFIG> ); # lit toutes les lignes et les débarrasse de leur "\n" Si on lit dans un fichier, c'est généralement qu'on a besoin de traiter toutes les lignes. Typiquement, on utilise une boucle while pour lire les lignes une par une et les traiter au fur et à mesure. Par exemple :

while( $ligne = <CONFIG> ){ # lit la ligne suivante

print "je viens de lire $ligne"; # affiche ce qu'on vient de lire }

Ce qui peut aussi s'écrire en raccourci :

while( <CONFIG> ){ # lit la ligne suivante ; la stocke dans $_ print "je viens de lire $_"; # affiche ce qu'on vient de lire

}

Cette façon de faire, très pratique, fonctionne uniquement si l'instruction conditionnelle d'une boucle while ne contient rien d'autre que l'opérateur <...>.

fermeture d'un fichier

Lorsqu'on a terminé de travailler avec un fichier, il vaut mieux le fermer pour, entre autres, finaliser les opérations d'écriture mises en attente dans un buffer. Cela se fait avec l'opérateur close de la façon suivante : close JOURNAL. Tests de fichiers

Avant d'ouvrir des fichiers pour les manipuler, il peut être utile d'obtenir des informations à leur sujet. Perl propose pour cela des opérateurs de tests de fichiers (ou répertoires) dont la syntaxe est dérivée de celle de la commande Unix test. Ces expressions s’écrivent à l’aide d’un opérateur suivi soit d'un descripteur de fichier, soit d’une chaîne de caractères qui représente le nom potentiel d’un fichier ou répertoire. Les opérateurs retournent une valeur vraie ou fausse, sauf exception. Voici les principaux opérateurs :

opérateur mnémonique vrai si

-r read le fichier ou répertoire est accessible en lecture (pour l'utilisateur courant) -w _{write le fichier ou répertoire est accessible en écriture (pour l'utilisateur courant)} -x execute le fichier est exécutable (pour l'utilisateur courant)

-e exists le fichier ou répertoire existe -z zero le fichier existe mais est vide

-s size le fichier ou répertoire est non vide (la valeur retournée est la taille en octets) -f file le fichier est « normal » (ce n'est ni un répertoire et ni un fichier spécial) -d directory le fichier est un répertoire (!!)

die "oulah... le fichier '$nom_fichier' existe déjà !\n" if -e $nom_fichier;

Ou bien on peut récupérer la taille d'un fichier en faisant : $taille = -s "/etc/yum.conf"; ou bien $taille = -s CONFIG; si le fichier a déjà été ouvert sous le descripteur CONFIG.

5. Expressions régulières

Cette section, résumée de la documentation perlrequick, couvre les éléments essentiels à la compréhension, la création et l'utilisation des expressions régulières (regular expressions en anglais, abrégé en regex) en Perl.

Simple correspondance de mots

syntaxe de base

L'expression régulière la plus simple est une chaîne de caractères. Une expression régulière constituée d'un mot

correspond (au sens des expressions régulières) à n'importe quelle chaîne qui contient ce mot :

"le sport est bon pour la santé" =~ /sport/

Cette expression est un test dans lequel sport est une expression régulière. Les // qui l'encadrent indiquent à Perl de rechercher une correspondance avec ce motif dans une chaîne. L'opérateur de liaison =~ associe la chaîne de gauche avec cette recherche de correspondance et renvoie vrai si une correspondance a été trouvée, faux sinon. On peut utiliser cette expression de la façon suivante :

if( "le sport est bon pour la santé" =~ /sport/ ){ print "c'est bien vrai";

}

Si on cherche à faire une correspondance avec une chaîne contenue dans la variable par défaut $_, alors la partie $_ =~ peut être omise :

$_ = "le sport est bon pour la santé"; if( /sport/ ){

print "c'est bien vrai"; }

Notez bien que :

• une correspondance exacte est requise ; par exemple, "Sport" =~ /sport/ est faux

• Perl va toujours chercher à obtenir une correspondance le plus tôt possible ; par exemple, "la terre est ronde" =~ /e/ va correspondre avec le premier e rencontré : celui de terre

métacaractères

Tous les caractères ne peuvent pas être utilisés « tel quel » dans une expression régulière. En effet certains caractères, appelés metacaractères, sont réservés pour une utilisation précise dans l'expression régulière. Il s'agit des caractères suivants, que nous allons découvrir au fur et à mesure :

{}[]()^$.|*+?\

Si vous avez vraiment besoin de les utiliser pour ce qu'ils sont et non pour la signification que Perl leur donne, préfixez-les avec un antislash \. Il en est de même pour le slash /, si c'est lui que vous utilisez pour délimiter l'expression régulière.

Enfin, vous avez compris qu'une correspondance est recherchée n'importe où dans la chaîne. Pour spécifier où rechercher la correspondance, on utilise des ancres :

• ^ impose la correspondance en tout début de chaîne • $ impose la correspondance en toute fin de chaîne • \b impose la correspondance à la limite d'un mot Par exemple :

"mentalement" =~ /ment/ # vrai "mentalement" =~ /^ment/ # vrai "mentalement" =~ /ment$/ # vrai "mentalement" =~ /^mental/ # vrai "mentalement" =~ /mental$/ # faux "mentalement" =~ /^mental$/ # faux "mentalement" =~ /^mentalement$/ # vrai "le sport c'est bien" =~ /\bsport/ # vrai

"le sport c'est bien" =~ /\bport/ # faux "le sport c'est bien" =~ /bien\b/ # vrai

Dans le dernier exemple, la fin de chaîne est considérée comme une limite de mot. Utilisation de classes de caractères

Une classe de caractères est une liste de caractères placés entre crochets [...]. Elle correspond à tout caractère unique présent dans la classe. Elle correspond à un caractère, qui doit faire partie de ceux indiqués. Par exemple :

/cha[rt]/ # correspond avec charme, chatte mais pas chaste ! "abracadavra" =~ /[bac]/ # correspond avec a

Dans ce dernier exemple, a est le premier caractère rencontré qui correspond, même si b est le premier de la classe de caractères.

On peut donc écrire quelque chose comme : print "Etes-vous d'accord ?"; chomp( $_ = <STDIN> );

if( /[Oo][Uu][Ii]/ ){

print "Il est d'accord !\n"; }

Cela permet de vérifier si l'utilisateur a tapé oui ou OUI ou Oui... En fait, ce problème est tellement fréquent qu'il est possible d'ajouter à l'expression régulière le modificateur i pour indiquer que la correspondance n'est pas sensible à la casse : if( /oui/i ) ...

Raccourcis pour les classes de caractères

Si on veut désigner une lettre minuscule, il faudrait normalement utiliser [abcdefghijklmnopqrstuvwxyz], ce qui est pour le moins pénible et illisible. Perl permet d'utiliser des intervalles de caractères grâce au tiret -. Ainsi, l'exemple précédent peut s'écrire plus simplement [a-z] ; ouf ! Ainsi, pour désigner une lettre de l'alphabet, on utiliserait donc la classe de caractères [a-zA-Z]. Mais cela est tellement courant que Perl propose un raccourci pour cela, ainsi que pour d'autres classes de caractères comme les chiffres, les blancs :

• . == [^\n] tout caractère sauf le retour à la ligne • \w == [A-Za-z0-9_] un caractère alphanumérique • \s == [\x20\f\t\r\n] un caractère "blanc"

• \d == [0-9] un chiffre

Notez que le ^ apparaissant en début de liste uniquement signifie « tout mais pas ça! ». Pour désigner un caractère qui n'est pas un chiffre, on peut donc écrire [^\d] mais il existe le raccourci \D ; de même pour \S, \W.

Par exemple /\d\d:\d\d:\d\d/ correspond avec les chaînes au format d'heure hh:mm:ss. Alternatives, regroupement et quantificateurs

Le metacaractère | signifie que le côté gauche ou droit peut correspondre. Pour correspondre à chien ou chat, on forme l'expression régulière chien|chat ou bien ch(ien|at).

Dans ce dernier exemple, vous voyez qu'on a utilisé les metacaractères () pour regrouper ien et at en une seule entité : cela est très fréquent dans les expressions régulières. Voici quelques exemples :

/(a|b)b/; # corespond avec 'ab' ou 'bb'

/(^a|b)c/; # correspond avec 'ac' en début de chaîne ou 'bc' n'importe où /planche (à voile|)/; # correspond à 'planche' ou 'planche à voile'

/planche (à (voile|repasser)|)/;

# correspond à 'planche' ou 'planche à voile' ou

# 'planche à repasser' : les groupes peuvent être imbriqués "20" =~ /(19|20|)\d\d/; # correspond avec l'alternative '()\d\d',

# parce que '20\d\d' ne peut pas correspondre

Les caractères de quantification ?, *, +, et {} permettent de spécifier le nombre de répétitions qu'on attend d'une partie d'une expression régulière. Les quantificateurs sont placés immédiatement après le caractère, la classe de caractères ou bien le groupe qu'on veut répéter. Voici leur signification :

? _{0 ou 1 fois}

+ _{1 fois ou plus}

* _{0 fois ou plus}

{n} _{exactement n fois} {n,} _{au moins n fois} {n,m} entre n fois et m fois

Par exemple, si on veut identifier une année sur 4 chiffres, on peut utiliser l'expression régulière /\d{4}/. Si on accepte que l'année soit sur 2 chiffres, on ne peut pas utiliser /\d{2,4}/ car cela accepterait les années sur 3 chiffres mais plutôt /\d{2}(\d{2}|)/ ou /\d{4}|\d{2}/ ce qui se lit beaucoup mieux sous la forme /\d\d(\d\d)?/. Modificateurs

Plusieurs lettres de modification d'option, aussi appelés modificateurs ou indicateurs ou drapeaux, peuvent être ajoutées juste après le délimiteur final d'une expression régulière afin de modifier son comportement par défaut :

• on a déjà rencontré i plus haut dans ce document, qui rend la correspondance insensible à la casse. • le modificateur x permet d'ajouter des caractères d'espacement à un motif afin de le rendre plus lisible.

• le modificateur s permet de faire une recherche en modifiant la classe de caractères . de sorte qu'il corresponde à n'importe quel caractère, même un retour à la ligne.

• le modificateur g permet de faire une recherche globale à l'aide d'une boucle while() au lieu de if() Les modificateurs peuvent être cumulés en les plaçant les uns derrière les autres.

Extraction de motifs

Les metacaractères de regroupement () permettent aussi l'extraction des parties de la chaîne qui ont correspondu. Pour chaque regroupement, les parties qui ont correspondu sont enregistrées dans les variables spéciales $1, $2, etc. Elles peuvent être utilisées comme des variables normales. Par exemple :

# extraction de heure, minute, seconde

$time =~ /(\d\d):(\d\d):(\d\d)/; # correspondance avec le format hh:mm:ss $h = $1; $min = $2; $sec = $3;

print "heure : ${h}h${min}m${sec}s\n";

Attention ! Une correspondance qui échoue laisse intactes les variables $1, $2, ... c'est pourquoi il faut toujours placer une correspondance de motif dans un if() ou un while() (et donc, pas comme dans l'exemple ci-dessus !) :

# extraction de heure, minute, seconde if( $time =~ /(\d\d):(\d\d):(\d\d)/ ){

$h = $1; $min = $2; $sec = $3; print "heure : ${h}h${min}m${sec}s\n"; }else{

print "$time : mauvais format\n"; }

Associées aux variables $1, $2, ..., il existe les variables de référence arrière \1, \2, ... qui ont exactement la même valeur. La seule différence entre les deux, c'est que $1, $2... doivent être utilisés à l'extérieur d'un motif alors que \1, \ 2... doivent être utilisés à l'intérieur d'un motif. Ainsi, par exemple, le motif /(\w\w\w)\s\1/ va accepter les séquences du genre aah aah ou bla bla mais pas meuh meuh ni coucou.

Rechercher/Remplacer

Si l'opérateur de correspondance /.../ peut être considérée comme le « rechercher » des éditeurs de texte, alors le « rechercher/remplacer » peut être accompli grâce à s/.../.../ : il s'agit de l'opérateur de substitution.

La syntaxe est s/regex/remplacement/modificateur. regex est une expression régulière, remplacement est une chaîne qui remplace dans la chaîne tout ce qui a correspondu avec le motif. L'opérateur =~ est aussi utilisé pour associer à la substitution une chaîne autre que $_. Si une correspondance est trouvée alors la substitution a lieu et s/// renvoie le nombre de substitutions faites, sinon il renvoie faux.

$_ = "le sport c'est bon pour la santé";

s/le sport/les jeux vidéo/; # maintenant "les jeux vidéo c'est bon pour la santé" s/bon/pô bon/; # maintenant "les jeux vidéo c'est pô bon pour la santé" s/^/je suis sûr que /; # maintenant "je suis sûr que les jeux vidéo c'est pô bon..." s/(\s+)(\w)/$1f/g; # maintenant "fe fuis fûr fue fes feux fidéo f'est fô fon..." split

split est un autre opérateur qui utilise des expressions régulières : son rôle est de décomposer une chaîne d'après un motif. split est utile pour les données séparées par des tabulations, des deux-points, etc. Sa syntaxe suit le schéma : @champs = split /regex/, $chaine_a_decomposer

Si la chaîne à décomposer est $_ , alors il est inutile de le préciser en 2ème argument.

Par exemple, en supposant que $_ contienne une ligne lue dans le fichier /etc/passwd, le split ci-dessous permet de récupérer le nom d'utilisateur, son uid et son gid :

($nom, $mdp, $uid, $gid) = split /:/;

On peut aussi s'en servir pour détacher les mots d'une phrase :

@mots = split /\s+/, 'tagada tsoin tsoin'; # renvoie ('tagada', 'tsoin', 'tsoin') join

join n'utilise pas les expressions régulières mais effectue l'inverse de split : elle regroupe une liste d'éléments en les joignant avec un délimiteur. Par exemple :

III. Mini-références

1. Opérateurs

Les opérateurs de Perl sont listés ici par ordre décroissant de priorité. Leur associativité est indiquée dans la colonne de gauche :

associativité opérateurs

→ parenthèses et arguments des opérateurs de liste

→ ->

++

--← **

← ! ~ \ + - (comme opérateurs unaires)

→ =~ !~

→ * / % x

→ + - . (comme opérateurs binaires)

→ << >>

opérateurs unaires nommés (tests de fichiers -X, rand) < > <= >= lt gt le ge (les « différent de ») == != <=> eq ne cmp (les « égal à ») → & → | ^ → && → || // ... ← ?: ← =+=-=*= etc. → , =>

opérateurs de liste (vers la droite)

← not

→ and

2. Quelques variables spéciales (parmi beaucoup !)

Nom(s) Signification Petit exemple

$1, $2, etc. Contient, lors d'opérations avec des expressions régulières, la valeur d'une expression partielle repérée entre parenthèses.

Lecture seule, modification impossible.

if(/from: (.*)/) { $expediteur = $1; }

$_ $ARG

utilisé comme argument par défaut dans les boucles comme foreach

accepté comme valeur/argument par défaut par certaines fonctions, dont print

chaîne par défaut pour les opérateurs d'expressions régulières @nombres = (1..10); foreach(@nombres) { print $_, "\n"; } $" $LIST_SEPARATOR

(chaîne de) caractère(s) utilisé(e) pour délimiter les éléments d'une liste lors de son interpolation dans une chaîne de caractères (par défaut : espace)

$" = "\n"; @Liste = (1,2,3,4); print "@Liste"; $! $ERRNO $OS_ERROR

dans la mesure ou une erreur est survenue, $! contient un message d'erreur ou un code d'erreur dans le contexte du programme. L'instruction ci-contre essaie d'ouvrir un fichier et donne en cas d'erreur le message d'erreur Perl prédéfini quand le fichier ne peut pas être ouvert et termine le programme.

open(FICHIER, "<pas_la.txt") or die "problème : $!";

$|

$OUTPUT_AUTOFLUSH

Quand cette variable est fixée sur une valeur différente de 0, Les sorties avec print ne sont pas mises en mémoire tampon, mais ont lieu à l'instant où l'instruction print est interprétée. Normalement, les sorties en Perl transitent en mémoire tampon pour être ensuite sorties sous forme de blocs.

$| = 1;

print "affiche moi ça tout de suite !";

@_ Contient les paramètres transmis lors de l'appel d'un sous-programme.

&DisBonjour("monde"); sub DisBonjour {

print "Bonjour $_[0]"; }

@ARGV _{Contient les paramètres transmis lors de l'appel} d'un script Perl.

$nom = shift @ARGV;

if (open(FICHIER, "< $nom")){ print "$nom ouvert!"; close(FICHIER); }

@INC _{Contient les chemins dans lesquels Perl doit} rechercher les modules.

print @INC;

%ENV _{Contient les variables d'environnement qui, à} l'appel du script, ont été transmises par le système appelant.

while( ($var,$val)=each %ENV){ print "$var=$val\n"; }

3. Perl 5 Cheat Sheet

CONTEXTES SYMBOLES TABLEAUX TABLES DE HACHAGE vide $scalaire tout: @tabl %hash

scalaire @tableau tranche: @tabl[0, 2] @hash{'a', 'b'} liste %hash element: $tabl[0] $hash{'a'} &sub

*glob VALEURS SCALAIRES

nombre, chaîne, référence, glob, undef REFERENCES

\ références $$foo[1] égale $foo->[1] $@%&* déréference $$foo{bar} égale $foo->{bar} [] réf.anon.tab ${$$foo[1]}[2] égale $foo->[1]->[2] {} réf.anon.hash ${$$foo[1]}[2] égale $foo->[1][2] \() liste de réfs.

NOMBRES CHAINES LIENS

PRIORITE des OPERATEURS = = perl.plover.com -> + . search.cpan.org ++ -- == != eq ne cpan.org ** < > <= >= lt gt le ge pm.org ! ~ \ u+ u- <=> cmp tpj.com =~ !~ perldoc.com * / % x SYNTAXE

+ - . for (LIST) { }, for (a;b;c) { } << >> while ( ) { }, until ( ) { }

op. unaires if ( ) { } elsif ( ) { } else { } < > <= >= lt gt le ge unless ( ) { } elsif ( ) { } else { } == != <=> eq ne cmp for equals foreach (ALWAYS)

&

| ^ REGEX : METACARACTERES REGEX : MODIFICATEURS && ^ début ch. /i ignorer maj/min

|| $ fin ch. (avant \n) /m traiter commme multi-lignes .. ... + un ou plus /s . inclut '\n'

?: * zero ou plus /x ignorer esp. blancs = += -= *= etc. ? zero ou un /g global

, => {3,7} répété dans la plage

op. listes () capturer REGEX : CLASSES DE CARACTERES not (?:) ne pas capturer . == [^\n]

and [] classe de carac \s == [\x20\f\t\r\n] or xor | alternative \w == [A-Za-z0-9_] \b limite de mot \d == [0-9]

\z fin de chaîne \S, \W et \D inversent

FAIRE NE PAS FAIRE LIENS use strict; "$foo" perl.com use warnings; $$nom_variable perlmonks.org my $var; `$userinput` use.perl.org open() or die $!; /$userinput/ perl.apache.org use Modules; parrotcode.org

FONCTIONS RETOURNANT DES LISTES

stat localtime caller VARIABLES SPECIALES

0 dev 0 second 0 package $_ variable par défaut 1 ino 1 minute 1 filename $0 nom du programme 2 mode 2 hour 2 line $/ séparateur d'entrée 3 nlink 3 day 3 subroutine $\ separateur de sortie 4 uid 4 month-1 4 hasargs $| autoflush

5 gid 5 year-1900 5 wantarray $! erreur syscall()/libcall() 6 rdev 6 weekday 6 evaltext $@ erreur eval()

7 size 7 yearday 7 is_require $$ ID de processus 8 atime 8 is_dst 8 hints $. numéro de ligne

9 mtime 9 bitmask @ARGV args de ligne de commande 10 ctime @INC chemin d'inclusion

11 blksz 3..9 seult @_ args du sous-programme 12 blcks avec EXPR %ENV variables d'environment

4. Documents de référence

• « Introduction à Perl » par Randal Schwartz, Tim Phoenix & Brian Phoenix (O'Reilly , 2006) Documentation de Perl (Perldoc) :

• perlintro • perlrequick • prelcheat Sites web :

• « Débuter en Perl » ( http://perso.univ-rennes1.fr/Francois.Dagorn/perl ) • « perlvar » (http://fr.selfhtml.org/cgiperl ...)

Table des matières

I. Syntaxe de Perl : les bases...1

1. Déclaration et portée des variables...1

2. Données scalaires...2

3. Listes et tableaux...3

4. Tables de hachage...4

5. Spécial...5

II. D'autres éléments importants...6

1. Fonctions définies par l'utilisateur...6

2. Modules...8

3. Structures de contrôle idiomatiques...9

4. Entrées/sorties...10

5. Expressions régulières...12

III. Mini-références...16

1. Opérateurs...16

2. Quelques variables spéciales (parmi beaucoup !)...17

3. Perl 5 Cheat Sheet...18