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

36.1 - Introduction

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 :

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
Attention!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

Attention!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.

Un premier exemple

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 :

Entrez votre nom 

Entrez le nom d'une personne que vous aimez 


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 :

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>";

 

Les fichiers

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");

Attention!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);

Autres éléments du langage

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 :

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";

36.2 - Référence

Les mots du langage

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 #.

Les chaînes de caractères

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 :

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

Type de données en PERL

Les scalaires

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

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

Les tableaux associatifs de scalaires

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>";

Opérateurs

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)

 

Des caractères très particuliers

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

Procédures

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 ou régulières

Présentation

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/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

[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

Exemples

  1.  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;
 

Extensions

Les conventions précédentes seraient très simples si on ne pouvait les combiner à loisir comme le montrent les exemples suivants :
On le comprend certaines d'entre elles sont des plus utilisées.

Des variables particulières

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.

Préséance

Les priorités des opérateurs Perl sont donnés dans l'ordre de priorité croissante:

Les arguments de l'interpréteur Perl

Définitions

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 :

Exemples

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);

Debug en Perl

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

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

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 :

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.

WindowsChargere!

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 :

  1. Charger Perl
  2. 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
  3. Installer un serveur HTTP, par exemple WebSite, Apache, OmniHTTP
  4. Dans le fichier autoexec.bat mettre la ligne :

  5. set PATH=%PATH%;c:\perl\bin
  6. Dans la configuration du serveur http indiquer le chemin de l'interpréteur Perl : c:\perl\bin\perl.exe
    1. dans OmniHTTP (cela se trouve dans l'onglet Advanced/Perl command line)
    2. dans Apache pour Windows les fichiers perl doivent commencer par la ligne #!c:\perl\bin\perl.exe
    3. dans WebSite en fonction des versions il faut lier dans l'explorateur de Windows le type de fichier pl avec l'interpréteur.
  7. 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 :
    1. 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
    2. Une fois un fichier d'extension perl chargé, aller dans le menu compile. En regard des cases :
      1. file extension => pl
      2. Compile command => perl &&
      3. Make command => pod2html --infile=&& (ceci pour générer les documentations au format POD)
      4. Debug command => perl -d &&
      5. Ne pas oublier de cliquer sur modify puis sur sauver
    3. 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
  8. 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
    1. le décompresser par Winzip
    2. dans le répertoire temp ou tmp dans le quel on l'a chargé faire sous une fenêtre dos
      1. perl Makefile.PL
      2. nmake test
      3. 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 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.

 


Haut

Haut Suivant Sommaire Recherche Fenêtre Glossaire Nouveau Bientôt Courrier Souscription Aide Copyright