Chapitre 36 : CGI et Introduction au langage PERL Chapitre 36 : CGI et Introduction au langage PERL| Dernière mise à jour | 15 mars 2000 | 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 (Common Gateway Interface) dans vos pages Web, en plaçant des menus déroulants ou des boutons radio dans votre page html, c'est-à-dire comment rendre le modèle Web un peu moins monodirectionnel qu'il n'est. Cette section vous explicite comment implémenter des programmes pour exécuter des traitements 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 perl-resources [http://wiht.link/perl-resources/]
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 relatifs au langage.
Une tentative de traduction de la documention est disponible ici : www.enstimac.fr/Perl/DocFr/perl.html
Les CPAN possèdent de nombreux sites miroirs et le site principal est www.CPAN.org
Il existe un groupe de news sur le langage PERL : comp.lang.perl.misc [news:comp.lang.perl.misc]
et un groupe français : fr.comp.lang.perl
Par contre, le groupe comp.lang.perl existe aussi, mais il 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 du formulaire :
<html> <head> <title>Voici un exemple</title> </head> <body> <form name="formulaire" method="POST" action="http://mon_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 à zéro"> </form> </body> </html>
Qui donnera ceci :
Voyons comment est élaboré le logiciel interprétant ces informations sur le serveur. Ce programme comme l'indique la ligne POST s'appelle procedure.pl.
Procedure.pl 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 donne le chemin de l'interpréteur PERL sur un système UNIX :
#!/bin/perl
Si le programme doit être exécuté de façon indépendante (en ligne de comande), cette ligne 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 comme Apache sous Windows interprètent cette ligne pour connaître 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 simplifier cette tâche. Il existe plusieurs modules ou librairies permettant de le faire, 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, par exemple à 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 (il fait partie de la distribution standart de perl 5.005_03).
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.
Continuons notre programme PERL par l'utilisation du module CGI et recupérons les paramétres
use CGI ;
$requete = new CGI ;
$nom_internaute = $requete->param('nom');
$nom_ami= $requete->param('nom2');
Certaines syntaxes peuvent différer et cela est explicité dans les chapitres suivants, mais dans tous les cas, l'utilisation de la variable $requete va nous permettre d'utiliser bon nombre de propriétés comme nous l'allons voir plus loin.
Dans le cas d'un page html statique, le serveur envoi automatiquement une entête (différent du head en html) qui indique au navigateur le type MIME du fichier. Dans le cas d'un cgi, nous devons prendre en charge l'entête.
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 avec l'instruction :
print $requete->header ;
La commande print est la fonction qui permet l'affichage sur la sortie standard de toute chaîne de caractères. Pour un cgi, la sortie sera envoyer au navigateur.
Nous allons simplement envoyer un petite page d'accusé de réception qui respecte la syntaxe html.
print "<html><head></head><body>"; print "<p>mon nom est $nom_internaute </p>"; print "</body></html>";
Le point virgule est obligatoire pour séparer chaque instruction. Cela revient à dire que chaque ligne doit être achevée par un point virgule, mise à 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.
le programme:
#!/bin/perl
use CGI ;
$requete = new CGI ;
$nom_internaute = $requete->param('nom');
$nom_ami= $requete->param('nom2');
print $requete->header;
print "<html><head></head><body>";
print "<p>mon nom est $nom_internaute </p>";
print "</body></html>";
|
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 ouvert.
Pour créer un nouveau fichier ou écrire au début d'un fichier existant, (en le vidant au passage) on utilise le symbole >.
Un fichier ouvert en lecture seule utilise <.
Ensuite vous pouvez remplir le fichier avec vos variables :
print FILEHANDLE "Nom: $nom_internaute\n"; print FILEHANDLE "Ami: $nom_ami\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 (symbole @ ) chacune des lignes de FILEHANDLE
Ainsi $lignes[0] sera la première ligne, $lignes[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. $tableau[1] # Est le second é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 $clavier d'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 , ie le contexte, 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
Reprenons notre exemple et sauvegardons les informations recueillies dans le fichier c:\temp\information.txt
#!/bin/perl
use CGI ;
$requete = new CGI ;
$nom_internaute = $requete->param('nom');
$nom_ami= $requete->param('nom2');
print $requete->header;
print "<html><head></head><body>";
print "<p>mon nom est $nom_internaute </p>";
print "</body></html>";
$mon_fichier= 'c:/temp/information.txt';
open (FILEHANDLE,">>$mon_fichier");
print FILEHANDLE "Nom: $nom_internaute\n";
print FILEHANDLE "Ami: $nom_ami\n";
print FILEHANDLE "-------------------------------\n";
close (FILEHANDLE);
|
Nous allons maintenant faire quelques vérifications sur les valeurs entrées par l'utilisateur de notre exemple précédent.
if ($nom_internaute 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 ((nom_internaute eq '') || (nom_ami 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;
}
Attention: il ne doit pas y avoir de ; entre une commande if et else.
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 {}
Nous pouvons maintenant affiner notre exemple et envoyer une page d'erreur si le formualire est mal rempli ou bien enregistrer les données et envoyer l'accuser de réception dans le cas contraire.
#!/bin/perl
# récuperer les paramétres
use CGI ;
$requete = new CGI ;
$nom_internaute = $requete->param('nom');
$nom_ami= $requete->param('nom2');
# tester la validité des paramétres
if (($nom_internaute eq '' )||($nom_ami eq '')){
# au moins un champ est vide
print $requete->header;
print "<html><head></head><body>";
print "<p>Erreur: vous devez remplir tous les champs</p>";
print "</body></html>";
}
else {
# tout est bon
print $requete->header;
print "<html><head></head><body>";
print "<p>mon nom est $nom_internaute </p>";
print "</body></html>";
# on sauvegarde les informations dans le fichier
$mon_fichier= 'c:/temp/information.txt';
open (FILEHANDLE,">>$mon_fichier");
print FILEHANDLE "Nom: $nom_internaute\n";
print FILEHANDLE "Ami: $nom_ami\n";
print FILEHANDLE "-------------------------------\n";
close (FILEHANDLE);
}
|
La condition while permet de répéter une action tant que la condition est vérifié :
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 d'effectuer 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 instructions 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 instructions 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:
| Opérateur | Description |
|
+ |
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 et 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 |
| -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 ;
}
&proc (*nom) ;
&proc ($nom) ;
Les exemples aideront le lecteur à en comprendre les subtilités.
s/config./ trouve les chaînes config1, config2, configuration, etc. mais pas les chaînes se terminant 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;}
s/^([^ ]*) *([^ ]*)/$2 $1/;
$chaine=~ s/(\W)/;$1/g;
$chaine=~ s/(\W)/\\$1/g;
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 Perl5, elles ont toutes des correspondances en noms étendus.
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 :
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ée |
| 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ée |
| D | supprime tous les points d'arrêt. |
| a ligne commande | assigne la commande indiquée à 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 | ré-exécute les nombres dernières commandes, (1 par défaut) |
| ! -nombre | ré-exécute 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 |
36.3 - Le langage Perl sur différentes plates-formes
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 Perl5.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!
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 :
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 il contient un débugger.
L'éditeur Note Tab, en deux versions Light (freeware) et Pro (shareware 20 US$), est un outil surprenant et rafraîchissant pour l'environnement Windows. Rapide et conçu en Suisse, on peut télécharger en ligne des librairies de langages de conception Web, dont celles consacrées à Perl. Allez faire un tour à http://www.notetab.com
Enfin sous Linux l'éditeur Kwrite permet la colorisation syntaxique en Perl et permet de coder de façon aisée.
