 |
Chapitre 28 : CGI et Introduction au langage PERL |
|
Chapitre 28 : CGI et Introduction au langage PERL |
28.1 - Introduction
28.2 - Référence
Les mots du langage
Les chaînes de caractères
Type de données en PERLLes scalaires
Les tableaux de scalaires
Les tableaux associatifs de scalairesOpérateurs
Des caractères très particuliers
Procédures
Les expressions rationnellesDes variables particulières
Précédences
Les arguments de l'interpréteur Perl28.3 - Le langage PERL sur différentes plates-formes
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.
Il existe plusieurs versions de langage PERL, celle qui est explicitée ici est la version Perl 5.003 qui existe en environnement UNIX, PC et Macintosh.
De bons manuels de langage PERL existent sur Internet, si vous désirez apprendre ce langage. 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/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.
En France, CPAN est hébergé à l'institut Pasteur [ftp://ftp.pasteur.fr/pub/Perl/CPAN]
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.
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
nom="Nom">
Entrez le nom d'une personne que vous aimez
<input nom2="Nom2">
<input type="submit"
value="Valider"><BR>
<input type="reset" value="Remettre a
zéro">
</form>
</body>
</html>
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 :
Elle donne le chemin de l'interpréteur
PERL qui se trouve dans l'exemple cité dans le répertoire bin.
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.
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 :
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 les versions actuelles de PERL 5.
Ce paquettage 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 expicité 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 chaine 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 standart de toute chaine 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");
Le symbole >> indique que le fichier va recevoir les nouvelles informations après son dernier enregistrement. Le nom FILEHANDLE est un nom de descipteur 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: ",$in{'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>
Il est également possible d'utiliser les expressions suivantes pour ouvrir le fichier d'entrée standart, ou pour le fichier de sortie standart comme ceci :
open(ENTREE, '-'); #Entrée standart open(SORTIE, '>-'); #Sortie standart
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 :
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 à :
La condition while permet de répéter une action par la syntaxe :
La condition foreach permet de répéter une action sur tous les éléments d'une liste :
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; expression; expression:)
{}
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 :
Par exemple la séquence suivante permet de sauter les lignes commentaires d'un fichier :
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'u 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 acolades 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'entraine 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 insctruction suivantes :
$premiere="ceci est une chaine" ; $deuxième='ceci est une autre chaine' ;
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 chaine" ; $deuxième='ceci est une $belle chaine' ;
Supposons que la variable $belle soit égale à 9, la variable $premiere vaut "ceci est une 9 chaine", alors que la variable $deuxieme vaut "ceci est une $belle chaine".
La concaténation de chaînes de caractères peut se faire de plusieurs façons :
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 chaine 2 à la chaine 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 1235 |
| $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 3"
Notons que les tableaux se concatènent de façon triviale par des opérations du type :
@toto=(@titi,1,4,@tutu) ;
Le langage vous permet de mettre des procédures entre parenthèses qui renvoient de tableaux devant les crochets d'assignation 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 avec la syntaxe suivante :
push(@toto,5);
Pour enlver 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 nombre d'élément du tableau toto est $#toto
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 et 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:
En plus de ces opérateurs on trouve les opérateurs
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 :
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
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 /B> | 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.
s/congig/ trouvera les chaînes config1, config2, configuration etc mais pas les chaines finies par config
s/^FILE/ ne reverra que les lignes commençant par FILE
s/conf$/ renverra les lignes se terminant
par conf
s/\.conf$/ renverra les lignes se terminant par .conf
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
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 :
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.
Les priorités des opérateurs PERL sont donnés dans l'ordre de priorité croissante:
Les options de l'interpréteur PERL permettent un certain nombre de paramétrages qu'il est bon de connaître.
Ces paramètres n'intéressent pas les utilisateurs Windows 16 bits car ils ne sont pas encore implémentés dans Perl 4.036 pour DOS.
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 :
Pour invoquer l'interpréteur PERL en mode debug (et bénéficier des commandes suivantes), il faut l'appeler avec l'option -d.
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.003 pour Windows 32 bits. Sur PC windows 3, les choses sont moins claires et Perl 4 est encore de rigueur.
Vous aurez besoin d'un éditeur de texte sous Windows et le meilleur est fait par un Français, Patrick Philippot et c'est e!.
Cet éditeur permet :
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.
Cet éditeur shareware à bas prix permet de bénéficier d'un environnement de programmation équivalent à ceux que l'on trouve en C++ ou en Basic sous Windows.
Sous windows NT ou 95, il vous faut associer les fichier d'extension pl et le programme perl.exe, par le menu paraètre/barre des taches/programme du menu démarré/avancé/options/types de fichier.