La section Les formulaires 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. 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.
Il vous permettra même de bénéficier sur votre Macintosh
ou votre PC 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 existent sur Internet, si vous désirez
apprendre ce langage, et ce en langue anglaise. Des interpréteurs
PERL sont également disponibles sur Internet. 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
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, il est bon de savoir que les archives Perl sont
au format tar.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://nom_du_serveur/cgi-bin/procedure.pl">
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 interpretent cette ligne pour connaitre le 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 plusieurs
librairies permettant de gérer cette interface, 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 tourner 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 une autre chapitre. Le module CGI.pm se trouve dans
les librairies CPAN de l'institut
Pasteur [ftp://ftp.pasteur.fr/pub/Perl/CPAN], il est encore 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 de futurs chapitres, 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 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 (@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);
La directive location permet de renvoyer un URL
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 :
6
| 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'anlyse 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