| Dernière mise à jour |
20 septembre
1999 |
Auteur |
Gilles
Maire |
| Serveur |
http://www.ungi.com/perl1.htm |
Adresse |
Gilles.Maire@UNGI.net |
La section consacrée aux
formulaires du chapitre HTML expliquait comment écrire la
partie cliente des procédures CGI (Gateway Common
Interface) dans vos pages Web, c'est-à-dire comment mettre des
menus déroulants, des boutons radio dans votre page html, c'est à
dire comment rendre le modèle Web un peu moins mono directionnel
qu'il l'est. Cette section vous explicite comment mettre en place
ces informations sur le serveur. Le langage le plus adapté pour
mettre en place les procédures CGI est le langage PERL
(Practical Extraction and Report Language), écrit par
Larry Wall.
Le langage Perl vous permettra en outre de bénéficier sur votre
Macintosh ou votre PC sous Windows d'un langage aussi puissant que
les ShellScripts d'Unix. Perl a connu quelques critiques en
1995-1996 comme tout l'univers des CGI car le langage JAVA tenait
le haut de l'affiche.
Mais aujourd'hui :
- l'annonce par Microsoft de Windows NT 5 incluant Perl
comme langage de scripting ;
- le support de Perl en mode kernel par les serveurs Apache et
Netscape permet une exécution des scripts en Perl sans lancement de
l'interpréteur Perl qui se trouve maintenant en mémoire en accès
direct avec le serveur HTTP ;
- le nombre grandissant de bibliothèques Perl
ont rendu à ce langage ses lettres de noblesse bien méritées.
Il existe plusieurs versions de langage PERL, celle qui est
explicitée ici est la version Perl 5.004 qui existe en
environnement UNIX, PC et Macintosh.
De bons manuels de langage PERL en langue anglaise existent sur
Internet, sans compter les nombreuses FAQ. Plusieurs interpréteurs
PERL sont également disponibles sur le Net. Le tout a l'avantage
d'être gratuit.
Tout ce que vous désirez connaître sur le langage PERL se trouve
sur la page
Yahoo
[www.yahoo.com/Computers_and_Internet/Programming_Languages/Perl/]
Mais c'est surtout un répertoire appelé CPAN (Comprehensive Perl Archive
Network) qui regroupe l'ensemble des ressources relatives
au langage PERL. On y trouve les documents, les sources, les
librairies officielles relatives au langage.
Les CPAN possèdent de nombreux sites miroirs et le site
principal est www.CPAN.org
Il existe une news sur le langage PERL : comp.lang.perl.misc
[news:comp.lang.perl.misc]
Désormais un groupe français existe : fr.comp.lang.perl
Par contre, le groupe comp.lang.perl existe aussi,
mais est obsolète.
Enfin les FAQ et autres documentations sont disponibles à l'adresse
www.perl.com/perl
Pour les utilisateurs de PC sous Windows , il est bon
de savoir que les archives Perl sont au format tgz (c'est à dire au
formé tar puis gzipé), pour lire ce format il est conseillé de
posséder une version de winzip récente.
- Pour fixer les idées nous allons maintenant écrire une
procédure CGI très simple qui va servir de base à la suite de
l'exposé. Cette procédure CGI sera lancée sur le serveur http après
la soumission d'une balise FORM par un utilisateur connecté.
Voici le code html de cette FORM :
<html>
<head>
<title>Voici un exemple</title>
</head>
<body>
<form method="POST"
action="http://serveur/cgi-bin/programme">
Entrez votre nom <input name="Nom">
Entrez le nom d'une personne que vous aimez <input
name="Nom2">
<input type="submit"
value="Valider"><BR>
<input type="reset" value="Remettre a
zéro">
</form>
</body>
</html>
Qui donnera ceci :
Voyons comment est élaboré le logiciel interprétant ces
informations sur le serveur. Ce programme comme nous le voyons dans
la ligne POST s'appelle procedure.pl.
Ce programme est un programme en PERL, mais la traduction en C
ou autre serait assez triviale.
Nous allons construire un programme qui va renvoyer un fichier
HTML construit dynamiquement à partir des données reçues.
La première ligne de ce programme en PERL est sur un système
UNIX :
- #!/bin/perl
Elle donne le chemin de l'interpréteur PERL qui se trouve dans
l'exemple cité dans le répertoire bin.
Si le programme doit être exécuté de façon indépendante, cette
ligne de commentaire peut être conservée sous PC Windows pour
assurer la compatibilité avec le système UNIX, sachant qu'elle sera
sans effet sous Windows.
Par contre, en mode CGI il faut la garder car certains serveurs
commes Apache sous Windows interprètent cette ligne pour connaitre
la nature du programme qu'ils doivent lancer.
Les autres serveurs HTTP sous Windows se contentent de lancer la
commande associée avec les fichiers d'extension pl.
Sur Unix elle indique à l'interpréteur de commandes que votre
programme est interprété en PERL et non plus par les interpréteurs
de commande shell, C Shell ou Bourne shell de votre système
UNIX.
Bien qu'il soit possible d'analyser les différents champs de
façon manuelle en PERL, nous allons utiliser un module qui permet
de masquer cette tâche. Il existe plusieurs modules ou librairies
permettant d'effectuer cette tâche, nous citerons les deux plus
connus :
- la librairie de l'Anglais Steve Brenner,
cgi-pl.pl qui fonctionnait au temps de la version 4 du
langage PERL et qui continue d'ailleurs de très bien fonctionner
sous PERL5.
- le module de l'Américain Lincoln D. Stein, CGI.pm qui
fonctionne à partir de PERL5.003 et qui est beaucoup plus
puissante et élégante.
Nous appuierons la suite de notre exposé sur cette librairie que
nous explorerons dans un des chapitres suivants. Le module CGI.pm
se trouve dans les librairies CPAN de l'institut Pasteur
[ftp://ftp.pasteur.fr/pub/Perl/CPAN], plus précisemment sous
Author/Stein s'il n'est pas contenu dans votre version de
PERL 5.
Ce paquetage s'installe sous /usr/local/lib/perl5 sous UNIX. Sur
Windows NT ou Windows 95, il faut installer manuellement les
fichiers CGI.pm dans c:/perl/lib/ et Carp.pm dans le sous
répertoire CGI de c:/perl/lib. Bien sûr, c:/perl/lib peut avoir un
nom légèrement différent en fonction de votre installation.
Nous continuerons notre programme PERL par la ligne :
use CGI ;
$html = new CGI ;
Certaines syntaxes peuvent différer et cela est explicité
dans les chapitres suivants, mais dans tous les
cas l'utilisation de la variable $html va nous
permettre d'utiliser bon nombre de propriétés comme nous l'allons
voir plus loin.
Maintenant, nous devons écrire une ligne indiquant le type
MIME du fichier que nous nous proposons de renvoyer vers le
navigateur.
Ce type est spécifié par la chaîne de caractères
Content-type: text/html\n\n
Mais le module CGI.pm nous permet de nous affranchir de cette
syntaxe par utilisation de l'instruction :
print $html->header ;
La commande print est la fonction qui permet
l'affichage sur la sortie standard de toute chaîne de
caractères.
Nous nous souvenons que la première variable du formulaire
était nom.
Ainsi pour imprimer la valeur de cette variable avec un
texte devant on peut utiliser la commande suivante :
print "<HTML><HEAD></HEAD><BODY>
mon nom est ", $html->param('nom') , "<P>
</BODY></HTML>\n" ;
Le point virgule est obligatoire pour séparer chaque instruction.
Cela revient à dire, que chaque ligne doit être achevée par un
point virgule, mis à part la dernière. En pratique, on termine même
la dernière ligne par un point virgule.
Nous verrons dans le chapitre consacré aux modules que cette
écriture peut encore être simplifiée, mais pour l'instant, il nous
faut étudier le langage PERL.
Maintenant que vous savez afficher les variables entrées par un
utilisateur, la chose la plus intéressante est de les sauvegarder
dans un fichier, voyons comment cela se fait :
Il faut utiliser la commande open pour ouvrir le
fichier. Cette commande a la forme suivante :
open(FILEHANDLE,">>nomdufichier");
Bien sûr FILEHANDLE peut être remplacé par un nom de descripteur de
votre choix comme par exemple F1, fic ou FICHIER.
Le symbole >> indique que le fichier va recevoir les
nouvelles informations après son dernier enregistrement. Le nom
FILEHANDLE est un nom de descripteur de fichier et sera différent
pour chaque nom de fichier.
Pour créer un nouveau fichier ou écrire au début d'un fichier
existant, (en le vidant au passage) on utilise le symbole >.
Ensuite vous pouvez remplir le fichier avec vos variables :
print FILEHANDLE "Nom:
",$html->param('nom'),"\n";
print FILEHANDLE "\n";
print FILEHANDLE
"--------------------------------------------------\n";
Ensuite il ne faut pas oublier de fermer le fichier :
close FILEHANDLE;
L'existence d'un fichier se teste par la commande -e
"nomdufichier".
L'ouverture d'un fichier en lecture, se fait par la commande
:
open(FILEHANDLE,"<nomdefichier");
En Perl même sous Dos, les noms de répertoires sont
donnés avec les caractères / et non pas avec les caractères \.
Pour lire le contenu d'un fichier, le langage PERL utilise
une syntaxe originale et puissante :
@lignes = <FILEHANDLE>;
Cette commande permet de ranger dans un tableau lignes chacune
des lignes de FILEHANDLE
Ainsi $ligne[0] sera la première ligne, $ligne[1] sera la deuxième
etc...
Un tableau est représenté par les syntaxes suivantes:
@tableau # désigne le tableau
$tableau[0] # Est le premier élément du tableau.
Pour remplir un tableau avec le contenu d'un fichier il suffit de
taper la commande @tableau = <FILEHANDLE>
Ceci est l'une des premières richesses du PERL.
Pour lire la chaîne de caractères $nom depuis
une entrée clavier, la commande suivante est suffisante :
$nom=<INPUT> ;
De même, si vous utilisez une syntaxe de la forme
$ligne=<FILEHANDLE>
vous lirez une seule ligne dans le fichier, c'est le type d'élément
qui informe si on lit l'ensemble du fichier (tableau) ou une ligne
(variable)
Il est également possible d'utiliser les expressions suivantes pour
ouvrir le fichier d'entrée standard, ou pour le fichier de sortie
standard comme ceci :
open(ENTREE, '-'); #Entrée standard
open(SORTIE, '>-'); #Sortie standard
Nous allons maintenant faire quelques vérifications sur les valeurs
entrées par les utilisateurs de notre exemple précédent.
Nous allons vérifier que les noms entrés ne sont pas vides et si
l'entrée est vide, renvoyer un message.
if ($in{'nom'} eq "") {
# Nous avons ici une chaîne vide :
# on quitte
exit;
}
Le test d'égalité entre des chaînes de caractères est
eq. Entre les nombres c'est
==.
Le test d'inégalité entre des chaînes de caractères est
ne. Entre les nombres c'est
!=.
La condition de test est :
if (..) {action ;}
On aurait pu tester les deux variables d'un seul tenant par les
lignes :
if (($in{'nom'} eq "") || ($in{'nom2'} eq "")) {
# exit;
}
La conjonction ou est matérialisée par le symbole |
| en perl.
Nous avons parlé de la condition if, on peut la
compléter par une condition else sous la forme
:
-
if (condition ) {
action1;
}
else {
action2;
}
Comme dans d'autres langages le mot elsif est la
contraction des mots clés else et
if, permettant dans les cas de tests imbriqués
d'étendre la syntaxe à :
if ( ) { }
elsif () {}
elsif () {}
else {}
La condition while permet de répéter une action
par la syntaxe :
while (condition) {
action ;
}
La condition foreach permet de répéter une
action sur tous les éléments d'une liste :
foreach $var (@liste) {
action ;
}
Une autre syntaxe est souvent utilisée dans le langage :
- { action } unless (condition)
;
Les étiquettes sont un élément non négligeable du langage
puisque elles permettent des branchements à l'intérieur d'une
instruction répétitive. Par exemple,
etiquette: while
(expression) {}
etiquette: while (expression) {}
continue {}
etiquette: for (expression de départ;
condition d'arrêt; incrément ) {}
etiquette: foreach (liste)
{}
etiquette: {} continue {}
sont des déclarations qui permettent l'utilisation le
branchement sur une étiquette par l'utilisation des mots clés
suivants :
- next : saute l'instruction en regard du mot
next
- last : continue le programme après le bloc en
cours
- redo : recommence toute la séquence
- Par exemple la séquence suivante permet de sauter les lignes
commentaires d'un fichier :
ligne: while (<F1>) {
next ligne if /^#/;
...
}
Le langage PERL permet de faire des opérations sur les chaînes
de caractères comme la substitution d'une chaîne par une autre.
Ceci se fait par la ligne :
$ligne =~ s/ancien/nouveau/
Pour répéter la substitution sur l'ensemble des lignes il suffit d
'appliquer la syntaxe suivante :
$ligne =~ s/ancien/nouveau/g
La destruction d'un ou plusieurs fichiers se fait par la syntaxe
unlink(liste de fichiers);
print "Location: http://www.adresse\n";
Le langage Perl est composés d'instructions comme tout langage,
plusieurs instructions peuvent être regroupées en blocs entourés
des symboles { et }.
A la différence d'autres langages Perl oblige la création d'un
bloc après les instruction comme par exemple if . Ainsi, par
exemple, le modèle suivant sera valide :
if ( condition )
{
instruction1;
instruction2
}
En cas d'emploi d'une seule instruction, les accolades sont tout de
même nécessaires, comme nous le mentionnions précédemment.
Le point virgule n'est pas nécessaire en fin de dernière
instruction puisqu'il n'y a pas lieu de séparer deux instructions.
Cependant, on le laisse généralement.
Les commentaires sont placés n'importe où dans le corps d'un
programme, ils commencent par l'instruction #. Nous verrons que
dans certaines instructions, l'emploi d'un # n'entraîne pas un
commentaire, par exemple "la chaine # toto" contient le caractère #
qui n'est pas ici pris comme une marque de début de
commentaire.
Il n'existe pas d'instruction pour mettre plusieurs lignes de
commentaires, il est donc nécessaire de commencer chacune de ces
lignes par le caractère #.
Le langage PERL étant un langage de manipulation de chaînes de
caractères, il est naturel que les instructions rendent cette
manipulation aisée.
Une chaîne de caractères se déclare par l'une des instruction
suivantes :
$premiere="ceci est une chaîne" ;
$deuxième='ceci est une autre chaîne' ;
En première approximation ces deux chaînes sont identiques, mais
l'utilisation des caractères ' ou " permettent de demander
l'interprétation des caractères. Ainsi, le deuxième exemple est
très différent :
$premiere="ceci est une $belle chaîne" ;
$deuxième='ceci est une $belle chaîne' ;
Supposons que la variable $belle soit égale à 9, la variable
$premiere vaut "ceci est une 9 chaîne", alors que la variable
$deuxieme vaut "ceci est une $belle chaîne".
La concaténation de chaînes de caractères peut se faire de
plusieurs façons :
- $chaine="toto" . "titi" ;
- $chaine=$chaine . "toto" ;
- $chaine="$chaine toto";
Une instruction originale est x elle permet la prolifération d'une
sous chaîne :
$chaine="*"x10 ;
$chaine vaudra "**********"; par contre l'instruction $chaine=2x"*"
; ne donnera rien.
De plus les opérateurs suivants peuvent être utilisés :
$chaine1=$chaine2 # assignation de la chaîne 2 à la chaîne 1
$chaine.=$chaine2 # permet la concaténation de plusieurs chaînes
Une variable qui est identifiée par le symbole $ (par exemple
$chaine) est un scalaire (entier, entier flottant ou chaîne de
caractères).
Pour assigner une valeur à une variable il suffit de faire
$variable=valeur; y compris pour les chaînes de caractères.
Une variable non initialisée prend la valeur 0, ou la chaîne vide
dans le cas des chaînes de caractères.
En outre, les variables $premier,
$Premier et $PREMIER sont toutes
différentes, puisque le langage est sensible aux majuscules et
minuscules.
Ainsi l'affectation $chaine="ok"; affecte la
valeur "ok" à la variable $chaine.
Pour affecter à la variable $toto la valeur
entière 5, il suffit de faire : $toto=5;
L'affectation de la chaîne "ok" à la variable toto
se fait par : $toto="ok";
Une chose très puissante en PERL réside dans la conversion
automatique des types. Prenons l'exemple suivant :
$a="3"
$b=4
$z=$a+$b
La variable $z vaut 7.
De même la commande
print "autre exemple $a"
imprime la chaîne autre exemple 3.
Enfin la notation des entiers suit les conventions montrées dans
l'exemple ci-dessous :
| Valeur |
Définition |
Commentaire |
| $titi=1234 |
Entier |
$titi vaut 1234 |
| $titi=1234.5 |
Réel |
$titi vaut 1235,5 |
| $titi=.123E3 |
Exposant |
$titi vaut 123 |
| $titi=0xff |
Hexadécimal |
$titi vaut 127 en décimal |
| $titi=011 |
Octal |
$titi vaut 9 en décimal |
| $titi=100_000 |
Grand nombre |
$titi vaut 100000 |
Les tableaux de scalaires commencent par le symbole @ pour désigner
le tableau dans son intégralité et s'initialisent par des
caractères entre parenthèses.
Par exemple
@nombres = (3,1,3,2,5);
et un élément du tableau se retrouve par le nom du tableau précédé
du signe $ et suivi des caractères [ et ]. Le premier élément est
indexé par le chiffre 0.
Ainsi on peut dire à partir de l'exemple précédent que
$nombres[0] est égal à 3.
Il existe un particularisme qui trouble parfois les
novices, mais qui n'est pas pénalisant car non obligatoire au bon
usage du langage :
@toto=(1,2,4) ; # est l'affectation du tableau @toto $toto[0] vaut ici 1
$toto=(1,2,4) ; # $toto n'est pas un tableau mais une variable qui vaut 4 (la dernière valeur)
$toto=@toto ; # $toto vaut ici 3 car la syntaxe dans ce cas donne la taille du tableau !
$toto="@toto" ; #toto vaut "1 2 4"
- Notons que les tableaux se concatènent de façon triviale par
des opérations du type :
@toto=(@titi,1,4,@tutu) ;
- Notons aussi que la déclaration suivante est parfaitement
valable :
@toto=(
1,
2,
4) ; # équivalent à @toto =(1,2,4) ;
Pour ajouter un élément à un tableau, il est également possible
d'utiliser la fonction push qui évite tout recopie en
mémoire du tableau avec la syntaxe suivante :
push(@toto,5);
Pour enlever le dernier élément d'un tableau, on utilise la
fonction pop avec la syntaxe suivante :
$valeurretournee=pop(@toto) ;
Enfin, et c'est important, le dernier indice du tableau toto est
$#toto. Ceci permet de dire que le nombre d'éléments d'un
tableau est $#toto+1
Ces tableaux sont identifiés par le caractère % ils sont indexés
non pas par des entiers mais par des clés. Par exemple le tableau
suivant :
%tableau=("Gilles",23,"Pierre", 3312)
permettra d'accéder à la valeur 23 par $tableau{Gilles}.
En général ce type de tableau se déclare de la façon suivante
:
$tableau{"Gilles"} = "Oui" ;
$tableau{"Pierre"} = "Non" ;
Il est intéressant de constater que si un tableau associatif est
nommé %valeurs, la variable $valeur est parfaitement définissable,
et n'a rien à voir avec son homologue.
Le tableau %SIG représente tous les signaux sous UNIX.
Le tableau %INC contient toutes les bibliothèques.
Un tableau très important en PERL est le tableau %ENV qui
contient toutes les variables d'environnement. Ainsi on retrouve la
variable PATH par %ENV{PATH} .
Pour connaître la liste de vos variables d'environnement il
suffit de taper la commande :
print %ENV ;
Si vous désirez que ces lignes soit un peu mieux présentées, la
ligne suivante présentera le résultat avec des bullets:
foreach ( keys (%ENV))
#la procedure keys donne tous les indices du tableau associatif %ENV
{
print "<LI><B>$_ </B> :<BR> $ENV{$_}\n" ;
#On imprime simplement chaque nom de variable d'environnement et #
sa valeur.
}
print "</UL>";
Tous les opérateurs du langage C sont valides:
- + ajoute deux nombres : $somme = $valeur + 1 ;
- += ajoute à la valeur à gauche. Exemple x += 2 sera équivalent
à x=x+2
- - et -= soustrait deux nombres : $total = $valeur - $somme
;
- / et /= divise deux nombres
- * et *= multiplie deux nombres
- == compare deux valeurs numériques dans une condition : if (
$somme == 10 )
- != teste si deux valeurs numériques sont différentes : while
($somme != 10 )
- -gt, -lt teste deux termes pour voir lequel est le plus grand
(Greater than) ou le plus petit (Lower than)
- = affecte un valeur à une variable : $valeur = 4 ;
En plus de ces opérateurs on trouve les opérateurs
- ** et **= pour l'exponentiation.
- () la liste vide pour initialiser un tableau à zéro.
- . et .= concatène deux chaînes
- x opérateur de répétitions
- .. opérateur de rang
- -f fichier teste si le fichier existe et n'est pas vide : if (
-f readme.txt )
- -d teste si le répertoire existe
- -l teste si le lien symbolique existe
- -x teste si le fichier est exécutable
- -r teste si le fichier est lisible
- -w teste si le fichier est accessible en écriture
- -o teste si le fichier appartient à l'UID
- -R teste si le fichier est lisible par l'UID réel
- -W teste si le fichier est accessible en écriture pour l'UID
réel
- -X teste si le fichier est executable par l'UID réel
- -O teste si le fichier appartient à l'UID réel
- -e teste si le fichier existe qu'il soit vide ou pas
- -z teste si le fichier est de taille nulle
- -s teste si le fichier n'est pas de taille nulle
- -f teste si le fichier est un fichier plain/text
- -d teste si le fichier est un répertoire
- -l teste si le fichier est un pipe (FIFO)
- -S teste si le fichier est un socket
- -b teste si le fichier est un fichier block spécial
- -c teste si le fichier est un fichier caractère spécial
- -u teste si le fichier a le setuid positionné
- -g teste si le fichier a le setgid positionné
- -k teste si le fichier a le sticky bit positionné
- -t teste si le fichier est ouvert en mode tty
- -T teste si le fichier est un fichier Texte
- -B teste si le fichier est un fichier binaire
- -M âge en jours du fichier.
- eq teste si deux chaînes de caractères sont identiques : if (
$chaine eq "oui" )
- ne teste si deux chaînes de caractères sont différentes
- lt teste si la première chaîne est avant la deuxième pour
l'ordre lexicographique : if ( $chaine lt "zz" )
- gt teste si la première chaîne est plus petite que la deuxième
pour l'ordre lexicographique
- le teste si la première chaîne est plus grande ou égale à la
deuxième pour l'ordre lexicographique
- ge teste si la première chaîne est plus petite ou égale à la
deuxième pour l'ordre lexicographique
- cmp compare deux chaînes lexicographiquement, A est avant a. Le
résultat est -1, 0 ou 1 .
- <=> compare deux numériques retourne -1, 1 ou 0.
- =~ permet que la recherche par les fonctions de recherche ne
s'effectue pas sur $_ mais sur le paramètre à gauche de =~ . Par
exemple s/titi/toto/ remplace dans la chaîne courante la valeur
titi par la valeur toto, mais $chaine=~s/titi/toto/ permet cette
opération sur la variable $chaine.
- !~ La négation de =~
- x Fonction de répétition sur une opération de chaîne de
caractères. @tableau = (1) x 80; # Tableau avec 80 numériques
1.
- x= Fonction d'assignation répétitive sur les numériques.
- .. opérateur de Rang : for (1 .. 10)
- La cotation en PERL comme dans tous les langages est un élément
à bien maîtriser puisqu'on le rencontre souvent et que sa
connaissance permet des astuces importantes comme nous allons le
voir :
- les simples cotes permettent de donner une chaîne de caractères
dont aucun des éléments ne sera interprété. Par exemple
print 'cette $ligne sera interprétée\n comme ceci\n' ;
- provoquera l'impression de la ligne :
cette $ligne sera interprétée\n comme ceci\n
- les doubles cotes permettent de forcer l'interprétation des
variables et des séquences interprétables. Par exemple
print "cette $ligne sera interprétée\n comme ceci\n" ;
- provoquera l'impression de la ligne (sachant que $ligne="dir":
)
cette ..... sera interprétée
comme ceci
- En outre dans une chaîne de caractères les valeurs suivantes
sont interprétées comme le montre le tableau suivant :
| Symbole |
Interprétation |
Exemple |
Résultat |
| \t |
tabulation |
print"1\t2"; |
1 2
|
| \n |
nouvelle ligne |
print"1\n2"; |
1
2
|
| \r |
retour ligne |
print"1\r2"; |
1
2
|
| \f |
form feed |
print"1\f2"; |
non affichable
|
| \v |
tabulation verticale |
print"1\v2"; |
non affichable
|
| \b |
retour arrière |
print"1\b2"; |
non affichable
|
| \a |
beep |
print"1\a2"; |
non affichable
|
| \e |
escape |
print"1\e2"; |
non affichable
|
| \0dd |
caractère octal |
print"1\0762"; |
1>2
|
| \xdd |
caractère héxadécimal |
print"1\x3a2"; |
1:2
|
| \cx |
caractère de contrôle |
print"1\c[2"; |
non affichable
|
| \l |
force le caractère suivant en
minuscule |
print"\lUNGI\n"; |
uNGI
|
| \u |
force le caractère suivant en
majuscule |
print"\lungi\n"; |
Ungi
|
| \L |
force la suite en minuscules jusqu'au caractère
\E |
print"\LUNG\EI\n"; |
ungI
|
| \U |
force la suite en majuscule jusqu'aux
caractères \E |
print"\Uung\Ei\n"; |
UNGi
|
| \Q |
force la suite jusqu'à \E à être interprétée en
expression régulière |
print"\Q.*\E\n"; |
UNGi
|
| \E |
marque de fin de
minuscule/majuscule/quote |
print"\Uung\Ei\n"; |
UNGi
|
| \\ |
empêche l'analyse de \ |
print"\\ungi\n"; |
\ungi
|
Les procédures sont appelées subroutines .
Leur déclaration est de la forme :
sub NOM {
...
} ;
Leur appel se fait par l'une des syntaxes équivalentes :
do NOM() ;
&NOM ;
&NOM () ;
Elles peuvent être appelées récursivement et les passages
d'argument peuvent se faire par référence en utilisant le symbole *
comme dans le langage C avec la syntaxe suivante:
sub proc
{
local ( *variable ) = @_[0] ;
$variable=3 ;
}
- Et l'appel se fait par :
&proc (*nom) ;
- au lieu de
&proc ($nom) ;
- Les expressions rationnelles en PERL peuvent être utilisées
dans les critères de certains moteurs de recherche. Elles sont donc
à connaître, même si elle peuvent paraître complexes.
Les exemples aideront le lecteur à en comprendre les subtilités.
- . : le point désigne n'importe quel caractère sauf le caractère
de marque de nouvelle ligne.
s/config./ trouve les les chaînes config1, config2,
configuration etc mais pas les chaînes finies par config
- \w : un caractère alphanumérique (caractère souligné
compris)
- \W : un caractère non alphanumérique
- \b : un caractère de limite de mot "'(,;.!? \n:
- \B : tout caractère non limite de mot
- \s : un caractère espace
- \S : tout caractère non espace
- \d : tout numérique
- \D : tout caractère non numérique
- | : alternative entre deux caractères ou groupe de
caractères
- (..): retourne l'argument $1 (voir exemple
1)
- ^... : indique que l'expression doit correspondre à un début de
ligne
s/^FILE/ ne reverra que les lignes commençant par FILE
- ....$: indique que l'expression doit correspondre à une fin de
ligne
s/conf$/ renverra les lignes se terminant par conf
s/\.conf$/ renverra les lignes se terminant par .conf
- {n,m}: n indique le minimum de fois où l'on doit trouver
l'expression et m le maximum
- {n,}: n indique le minimum de fois où l'on doit trouver
l'expression et m le maximum ( pas de maximum : {n} , pas de
minimum : {,m} )
- * : indique que l'expression précédente peut être présente (
équivalent à {0,} )
- + : indique que l'expression précédente doit être présente une
fois ou plus ( équivalent à {1,} )
- ? : indique que l'expression doit être présente une fois au
plus ( équivalent à {0,1} )
- [] : classe de caractères
Les classes de caractères contiennent les caractères qui peuvent
être contenus dans l'expression. Le caractère - entre deux valeurs,
autorise toutes les valeurs comprises entre ces deux valeurs,
le caractère ^ interdit le ou les caractères suivants. Les
expressions régulières ne sont bien sûr par autorisées à
l'intérieur des crochets [ et ].
Ainsi
[abc] # a b ou c
sont autorisés
[^abc] # ni a, ni b ni c ne
sont autorisés
[a-z] #
toutes les lettres minuscules de a à z
[^a-z] # pas de
lettre minuscule
[a-zA-Z] # pas de lettres ni minuscules ni
majuscules
[a-z]+ #
toute suite de lettres
Nous pouvons ainsi analyser l'exemple suivant :
s/AUTOEXEC\.BA[TK]/ # permet de trouver le nom
AUTOEXEC.BAT ou AUTOEXEC.BAK
-
if (/Time: (..):(..):(..)/) { $heure = $1; $minute = $2; $seconde = $3;}
- permet d'utiliser $1, $2 et $3 comme résultat de (..) (..) (..)
sachant que .. signifie deux caractères.
s/^([^ ]*) *([^ ]*)/$2 $1/;
- permet de permuter deux mots : ([^ ]*) séparés par un ou
plusieurs blancs : *)
$chaine=~ s/(\W)/;$1/g;
- permet d'insérer un ; après chaque mot trouvé par (\W) Pour
insérer le symbole \ après chaque mot on utilisera la même syntaxe
en cotant le symbole \
$chaine=~ s/(\W)/\\$1/g;
- Les conventions précédentes seraient très simples si on ne
pouvait les combiner à loisir comme le montre les exemples suivants
:
- *? : l'expression doit correspondre 0 ou plusieurs fois
- +? : l'expression doit correspondre 1 fois ou plus
- ?? : l'expression doit correspondre 0 ou 1 fois
- {n}? : l'expression doit correspondre 1 fois exactement
- {n,}? : l'expression doit correspondre au moins n fois
- {n,m}? : l'expression doit correspondre au moins n fois mais au
plus m fois
- On le comprend certaines d'entre elles sont des plus
utilisées.
Certaines variables sont très usuelles en PERL, il faut convenir
que ces noms de variables ne sont pas très mnémotechniques mais
comme vous le verrons dans les évolutions PERL 5, elles ont toutes
des correspondances en noms étendus.
- $$ numéro du process (UNIX)
- $% numéro de la page du device de sortie
- $& la chaîne de caractères correspondant à la dernière
recherche
- $' valeur suivant le mot recherché dans la chaîne trouvée
- $( gid réel du process (UNIX)
- $) gid effectif du process (UNIX)
- $* est à 1 si plusieurs lignes contiennent la chaîne
recherchée
- $- nombre de lignes imprimées sur la page de sortie
- $+ la dernière correspondance trouvée par une recherche
- $. ligne courante
- $, séparateur de champs en sortie de la commande print utilisée
avec des , en séparateur
- $; séparateur pour les tableaux multi dimension
- $/ séparateur de champs (nouvelle ligne par défaut)
- $| de valeur non nulle force un flush après chaque écriture sur
le canal de sortie (0 par défaut).
- $\ marque de fin de ligne en sortie de la commande print.
- $" séparateur de champs tableau en sortie de la commande
print.
- $< uid réel du process (UNIX)
- $= longueur de la page de sortie
- $: jeu de caractère après lequel une chaîne peut être coupée
pour remplir le champ suivant.
- $> uid effectif du process (UNIX)
- $? statut retourné par la dernière commande
- $! valeur du dernier code d'erreur (errno)
- $@ dernier message d'erreur provoqué par PERL
- $# format de sortie pour les nombres imprimés (ne plus utiliser
en PERL 5)
- $[ index du premier élément d'un tableau
- $] version de PERL
- $^ nom du format courant d'en-tête de page
- $^A la valeur courante de l'accumulateur write() pour less
ligne format()
- $^D état du flag de debug
- $^F nombre de descripteurs de fichier système
- $^I valeur courante pour l'extension inplace-edit (voir option
-i)
- $^L envoie un Form Feed sur le canal de sortie
- $^P flag interne que le debugueur remet à zéro.
- $^T temps d'exécution de PERL
- $^W valeur de la chaîne de Warning
- $^X nom d'exécution du programme PERL
- $_ Valeur courante
- $` valeur précédant la chaîne trouvée lors de la précédente
recherche
- $~ nom du canal de sortie
- $0 nom du fichier contenant le programme PERL en cours
d'exécution
- $ARGV nom du fichier courant quand la lecture utilise
<>
- @ARGV contient les arguments passés au programme
- @INC contient les programmes PERL utilisés en librairie
- %INC contient les entrées de tous les fichiers inclus par la
directive require
- %ENV contient les variables d'environnement
- %SIG contient la table de tous les signaux
- Les priorités des opérateurs PERL sont donnés dans l'ordre de
priorité croissante:
- += -= *= etc.
- ?:
- ..
- || qui sera avantageusement remplacé par or
- && qui sera avantageusement remplacé par
and
- | ^
- &
- == != <=> eq ne cmp
- < > <= >= lt gt le ge
- chdir exit eval reset sleep rand umask
- -r -w -x etc.
- << >>
- + - .
- * / % x
- =~ !~
- ! ~ etc
- **
- ++ --
- '('
- Les options de l'interpréteur PERL permettent un certain nombre
de paramétrages qu'il est bon de connaître.
Les arguments peuvent être combinés et placés en argument de
la commande perl (perl -s file.pl) ou dans la première ligne
du programme (#!/usr/bin/perl -s)
Voici la liste des options :
- -0digits : spécifie le séparateur de champs en octal. La valeur
00 permettra le lire le fichier en mode paragraphe.
- -a : provoque l'auto split quand il est utilisé avec les
paramètres -n et -p.
- -c : vérifie la syntaxe du programme sans l'exécuter
- -d : exécute le programme PERL en mode debug
- -Dnombre : positionne les flags de debug.
- -ecommande : permet de rentrer une commande sans passer
par un fichier perl et de l'éxécuter.
- -iextension : le fichier utilisé avec la construction
<> sera édité comme fichier d'entrée/sortie.
- -Idirectory : indique où sont les fichiers
d'inclusion.
- -loctnum : permet de terminer les lignes par le
caractère octnum en octal.
- -n : exécute une boucle sur tout le fichier pour exécuter le
programme sans afficher le résultat
- -p : exécute une boucle sur tout le fichier pour exécuter le
programme en affichant le résultat
- -P : le programme est passé au préprocesseur C avant d'être
exécuté.
- -s : indique que les options passées entre le nom du programme
et les arguments du programme ne sont pas à prendre comme des
arguments de l'interpréteur PERL mais du programme appelé.
- -S : perl utilise la variable PATH pour rechercher le script à
exécuter
- -u : provoque un core dump après la compilation du script
- -U : permet de faire des opérations non sécurisées
- -v : affiche la version du compilateur PERL.
- -w : affiche des messages d'attention sur les identifieurs qui
sont utilisés une seule fois ou utilisés avant d'avoir été
initialisés, ainsi que sur les procédures récursives qui
s'appellent plus de 100 fois.
- -xrépertoire : le script est compris dans un message (ou
un courrier) le programme ne commencera qu'après le symbole
#!.
-
find . -name '*.bak' -print0 | perl -n0e unlink
-
perl -ane 'print pop(@F), "\n";' remplace while (<>) { @F = split('
'); print pop(@F), "\n"; }
-
#!/usr/bin/perl -pi.bak s/foo/bar/;
est équivalent à :
#!/usr/bin/perl
while (<>)
{
if ($ARGV ne $oldargv)
{
rename($ARGV, $ARGV . '.bak');
open(ARGVOUT, ">$ARGV");
select(ARGVOUT);
$oldargv = $ARGV;
}
s/foo/bar/;
}
continue
{
print;
# this prints to original filename
}
select(STDOUT);
- Pour invoquer l'interpréteur PERL en mode debug (et bénéficier
des commandes suivantes), il faut l'appeler avec l'option
-d.
- h : affiche une aide
- S : trace la pile
- s : exécute une instruction pas-à-pas
- f : exécute la suite du programme jusqu'à la fin de la
procédure courante
- c : continue l'exécution jusqu'au prochain point d'arrêt
- c ligne : continue l'exécution jusqu'à la ligne
spécifiée
- <CR> : répète la dernière commande n et s
- l min+incr : liste incr + 1 lignes commençant à
min.
- l min-max : liste les lignes comprises entre min
et max
- l ligne : liste la ligne indiquée
- l procedure : liste la procédure
- /pattern/ : cherche l'expression
- ?pattern? : cherche l'expression en arrière
- L : liste les lignes pourvues de points d'arrêt
- S : liste les noms de toutes le procédures
- t : met en service/hors service la trace
- b ligne condition : met un point d'arrêt avec
éventuellement une condition sur la ligne indiqué
- b procedure condition : met un point d'arrêt avec
éventuellement une condition sur la première ligne de la procédure
indiqué
- d ligne : supprime le point d'arrêt de la ligne
indiqué
- D : supprime tous les points d'arrêt.
- a ligne commande : assigne la commande indiqué à la
ligne line.
- A : détruit toutes les actions
- <commande : assigne la commande commande avant
chaque affichage du debugger
- >commande : assigne la commande commande après
chaque affichage du debugger
- Vpackage : affiche toutes les variables du package
- !nombre : refait les nombres dernières commandes,
(1 par défaut)
- ! -nombre : refait la commande d'il y a nombre
d'instructions
- H -nombre : affiche les nombre dernières
commandes.
- q ou ^D : quitte
- command : exécute la commande PERL command
- p expr : affiche expr comme le ferait la commande
print expr
Sous UNIX le fichier PERL sera rendu exécutable par la commande
chmod +x nom du fichier. La première ligne du programme est
#!/bin/perl. Cette ligne indique que le l'interpréteur de
commande est le langage PERL, et le chemin d'accès de
l'interpréteur peut évidemment varier d'une installation à l'autre.
Le chemin des librairies est renseigné par la variable
d'environnement PERLIB.
Sur PC Windows, vous devez installer PERL 5.004 pour Windows 32
bits.
Vous aurez besoin d'un éditeur de texte sous Windows et le choix
peut être celui que l'on doit à un Français, Patrick Philippot et
c'est e!.
Cet éditeur permet :
- d'afficher les mots clés, syntaxes et procédures PERL avec des
couleurs spécifiques,
- d'exécuter et déboguer les programme PERL en affichant les
erreurs d'une couleur spécifique dans l'éditeur.
- de pouvoir naviguer dans les fonctions PERL
Ces fonctions sont disponibles depuis la version 2.05 et activables
par le fichier prl.hdf livré avec celle-ci. Pour activer la
fonction, il suffit d'activer dans le menu file l'item
associate et de spécifier en regard de l'extension pl
le champs hilite filename à prl.
e!
- Page officielle : MainSoft
[http://ourworld.compuserve.com/homepages/mainsoft]
Cet éditeur shareware à bas prix permet de bénéficier d'un
environnement de programmation équivalent à ceux que l'on trouve
pour les autres langages.
Pour
installer Perl sur PC :
- Charger Perl
- L'installer en suivant les instructions, le mieux est de
l'installer dans le répertoire c:\perl. Demandez
l'installation de la documentation en HTML
- Installer un serveur HTTP, par exemple WebSite, Apache,
OmniHTTP
- Dans le fichier autoexec.bat mettre la ligne :
set PATH=%PATH%;c:\perl\bin- Dans la configuration du serveur http indiquer que le chemin de
l'interpréteur Perl : c:\perl\bin\perl.exe
-
- dans OmniHTTP (cela se trouve dans l'onglet Advanced/Perl
command line)
- dans Apache pour Windows les fichiers perl doivent commencer
par la ligne #!c:\perl\bin\perl.exe
- dans WebSite en fonction des versions il faut lier dans
l'explorateur de Windows le type de fichier pl avec
l'interpréteur.
- Pour travailler à la fabrication des fichiers HTML le mieux est
d'installer l'éditeur de texte e!. Pour le configurer il suffit de
faire les opérations suivantes :
-
- dans le menu fichier de l'éditeur (et pas dans la fenêtre
centre de contrôle) cliquer sur Associate puis dans la case
FileName Extension mettre pl, dans la case Hilite
Filename mettre prl
- Une fois un fichier d'extension perl chargé, aller dans le menu
compile. En regard des cases :
-
- file extension => pl
- Compile command => perl &&
- Make command => pod2html --infile=&& (ceci
pour générer les documentations au format POD)
- Debug command => perl -d &&
- Ne pas oublier de cliquer sur modify puis sur
sauver
- Pour sauvergarder les fichiers Perl en mode Unix ce qui marche
très bien sur Windows et qui est optionnel, aller à
local/set et cliquer sur End Of Line à
LF
- Pour installer des modules comme CGI.pm après les avoir chargé
sous la de fichier module.pm.tgz sur un serveur ftp CPAN,
puis
-
- le décompresser par Winzip
- dans le répertoire temp ou tmp dans le quel on l'a chargé faire
sous une fenêtre dos
-
- perl Makefile.PL
- nmake test
- nmake install
Le reste est affaire d'habitude
Il est à noter que l'environnement Perl Builder, s'il vaut
120 US$, est téléchargeable à l'adresse http://www.solutionsoft.com
Cet environnement est assez convivial à utiliser.
Enfin sous Linux l'éditeur Kwrite permet la colorisation
syntaxique en Perl et permet de coder de façon aisée.
Chapitre 36 : CGI et
Introduction au langage PERL