SELFHTML/Aides à la navigation CGI/Perl Fonctions Perl| SELFHTML/Aides à la navigation CGI/Perl Fonctions Perl |
 |
Fonctions pour le contrôle du script en cours |
|
|
 | |
Les fonctions rassemblées ici servent avant tout à fixer certaines choses pour le Script, à contrôler ou à influer sur le cours du script. Ainsi un 
sous-programme peut rechercher pas exemple l'endroit duquel il a été appelé. Il est possible de vérifier pour une variable si elle a une valeur ou non. La validité (durée de vie) de variables peut être limitée à certains passages du script. Les scripts peuvent être interrompus dans des situations critiques ou en cas d'erreur ou bien sortir des avertissements.
|
Recherche l'endroit à partir duquel la partie de programme actuelle a été appelée et de quel contexte.
Attend comme paramètre:
1. (facultatif) La profondeur à laquelle la recherche doit remonter vers l'arrière exprimée sous forme de nombre. Si vous voulez expérimenter ce paramètre, essayez dans un premier temps de transmettre la valeur 1. Des valeurs plus élevées peuvent avoir pour conséquence que moins d'informations qu'espéré ne soient trouvées.
Renvoie une scalaire ou une liste au choix. Quand la valeur renvoyée est seulement sauvegardée dans une scalaire, celle-ci contient après l'appel de la fonction, le nom du package . Quelles autres valeurs renvoyées sont sauvegardées dans une liste, c'est ce que montre l'exemple suivant.
#!/usr/bin/perl -w
use strict;
use CGI::Carp qw(fatalsToBrowser);
print "Content-type: text/html\n\n";
print '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">', "\n";
print "<html><head><title>Sortie du test</title></head><body>\n";
my $Infos = demarrer_appels();
print "$Infos\n";
print "</body></html>\n";
sub demarrer_appels {
my $simples_infos = appel_simples_infos();
my $D_A = "<h3>Informations simples d'appel:</h3><p>".$simples_infos."</p>";
my $infos_detaillees = appel_infos_detaillees();
$D_A = $D_A."<h3>Informations détaillées d'appel:</h3><p>".$infos_detaillees."</p>";
return($D_A);
}
sub appel_simples_infos {
(my $Package, my $fichier, my $ligne) = caller();
my $A_S_I = "<b>L'appel a eu lieu à partir du package:</b> ".$Package."<br>" if (defined $Package);
$A_S_I = $A_S_I."<b>L'appel a eu lieu à partir du fichier:</b> ".$fichier."<br>" if (defined $fichier);
$A_S_I = $A_S_I."<b>L'appel a eu lieu à partir de la ligne du programme:</b> ".$ligne if (defined $ligne);
return($A_S_I);
}
sub appel_infos_detaillees {
(my $Package, my $fichier, my $ligne, my $sous_programme, my $HasArgs, my $WantArray, my $EvalText, my $IsRequire) = caller(1);
my $A_I_D = "<b>L'appel a eu lieu à partir du package:</b> ".$Package."<br>" if (defined $Package);
$A_I_D = $A_I_D."<b>L'appel a eu lieu à partir du fichier:</b> ".$fichier."<br>" if (defined $fichier);
$A_I_D = $A_I_D."<b>L'appel a eu lieu à partir de la ligne du programme:</b> ".$ligne."<br>" if (defined $ligne);
$A_I_D = $A_I_D."<b>L'appel a eu lieu à partir du sous-programme:</b> ".$sous_programme."<br>" if (defined $sous_programme);
$A_I_D = $A_I_D."<b>HasArgs:</b> ".$HasArgs."<br>" if (defined $HasArgs);
$A_I_D = $A_I_D."<b>WantArray:</b> ".$WantArray."<br>" if (defined $WantArray);
$A_I_D = $A_I_D."<b>EvalText:</b> ".$EvalText."<br>" if (defined $EvalText);
$A_I_D = $A_I_D."<b>IsRequire:</b> ".$IsRequire."<br>" if (defined $IsRequire);
return($A_I_D);
}
|
L'exemple envoie du code HTML au navigateur. Pendant la sortie HTML le sous-programme demarrer_appels() est appelé. La valeur renvoyée par l'appel est sauvegardé dans la scalaire $Infos et ensuite est sortie.
Le sous-programme demarrer_appels() appelle de son côté les sous-programmes appel_simples_infos() et appel_infos_detaillees(). À partir des valeurs renvoyées par ces deux sous-programmes, est composée une chaîne de caractères nommée $D_A qui est ensuite sortie.
Dans appel_simples_infos figure la variante simple d'un appel typique de caller. Ici trois éléments de liste sont attendus comme valeur renvoyée: le nom du package appelant, celui du fichier Perl appelant et le numéro de la ligne de programme dans laquelle l'appel a eu lieu.
Le sous-programme appel_infos_detaillees montre quant à lui l'appel avancé de caller. Ici les valeurs renvoyées attendues sont huit éléments de liste. Outre les trois éléments de la variante simplifiée, ce sont le nom du sous programme appelant et les informations complémentaires suivantes:
$HasArgs est égal à 1, quand lors de l'appel des arguments ont été transmis (est également considérée comme telle une liste vide), sinon est égal à 0.
$WantArray sauvegarde si la fonction a été appelée dans un contexte liste.
$EvalText sauvegarde un contenu quand l'appel a lieu à partir d'une évaluation avec eval() (pas forcément cependant pour les évaluations de bloc avec eval{...}.
$IsRequire sauvegarde 1 comme contenu quand l'appel a eu lieu à partir de eval, et que l'une des fonctions use ou require sont en jeu.
Les deux sous-programmes appel_simples_infos et appel_infos_detaillees dans l'exemple ci-dessus composent à partir des informations recueillies les chaînes de caractères $A_S_I ou $A_I_D et sortent celles-ci à la fin.
|
|
Les variables, que ce soient des scalaires, des éléments de listes ou d'array ou des éléments de hash ont pour valeur undef aussi longtemps qu'une valeur quelconque ne leur a pas été affectée explicitement. Avec cette fonction, vous pouvez vérifier si une valeur a déjà été oui ou non affectée à une variable.
Attend comme paramètre:
1. la variable à vérifier.
Renvoie 1 ou bien une valeur logique "vrai", si la variable s'est vu affecter une valeur, et 0 ou bien une valeur logique "faux", quand aucune valeur n'est affectée.
#!/usr/bin/perl -w
use strict;
use CGI::Carp qw(fatalsToBrowser);
my $premiere_phrase;
my $seconde_phrase = "Le premier est mordu par les chats";
print "Content-type: text/html\n\n";
print '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">', "\n";
print "<html><head><title>Sortie du test</title></head><body>\n";
&enoncer_phrase;
$premiere_phrase = "...et le dernier, c'est bien connu, par les chiens";
undef $seconde_phrase;
print "<p></p><i>So - et maintenant encore une fois:</i></p>";
&enoncer_phrase;
print "</body></html>\n";
sub enoncer_phrase {
if(defined $premiere_phrase) {
print "La première phrase est <b>$premiere_phrase</b><br>\n";
}
if(defined $seconde_phrase) {
print "La deuxième phrase est <b>$seconde_phrase</b><br>\n";
}
}
|
Le script en exemple définit d'abord deux scalaires nommées $premiere_phrase sans affectation de valeur et $seconde_phrase avec une affectation de valeur. Le script contient un sous-programme nommé enoncer_phrase. Y est vérifié pour chacune des deux scalaires avec defined si une valeur leur a été affectée. Si c'est le cas, la valeur est sortie.
Le script envoie du code HTML au navigateur et appelle ici d'abord le sous-programme enoncer_phrase. Ensuite, la scalaire $premiere_phrase, jusqu'alors indéfinie reçoit une valeur, et la scalaire $seconde_phrase est fixée avec undef dans un état où aucune valeur (ou plutôt la "non-valeur" undef) lui est affectée. Après quoi enoncer_phrase est appelé encore une fois.
Au premier appel de enoncer_phrase seul est sorti "Le premier est mordu par les chats", au deuxième appel seulement "...et le dernier, c'est bien connu, par les chiens".
La valeur initiale undef d'une variable, que vous pouvez rétablir grâce à la fonction undef est différente de la chaîne de caractères vide (""). Une chaîne de caractères vide est tout à fait une valeur affectée!
|
|
Termine un script quand il est vain de continuer son exécution. Est employé volontiers quand un fichier important ne peut pas être ouvert.
Écrit les messages d'erreur sur la sortie standard d'erreur STDERR et termine le script avec la valeur actuelle de la variable prédéfinie $!. Pour le port CGI d'un serveur WWW la sortie standard d'erreur est la plupart du temps un fichier Log, dans lequel ces messages d'erreur sont réunis. Recherchez le cas échéant dans la documentation du serveur Web où et comment les messages d'erreur sont recensés.
Attend comme paramètre:
1. une liste qui doit être écrite sur la sortie standard. Pour le bien, la liste contient un ou plusieurs messages d'erreur correspondants.
#!/usr/bin/perl -w use strict; use CGI::Carp qw(fatalsToBrowser); open(TEXT, "</daten/texte/absent.txt") || die "Erreur survenue: $!"; my @lignes = <TEXT>; close(TEXT); |
L'exemple essaie d'ouvrir un fichier avec open, fichier qui cependant n'existe pas. Ce qui fait que l'embranchement derrière l' opérateur logique || (qui figure pour "ou") est actif. Là est notée la fonction die. Elle écrit sur la sortie standard d'erreur qu'une erreur est survenue. En notant également la variable prédéfinie $! dans la sortie, sera également recensée dans le protocole, la nature de l'erreur survenue. Dans ce cas, l'instruction use CGI::Carp qw(fatalsToBrowser) est aussi d'une grande aide car l'erreur est ainsi en outre également écrite sur la sortie standard et peut selon le cas également atterrir à l'affichage dans le navigateur.
|
|
Les scripts Perl sont normalement compilés en interne en code d'opération (operationscode) (ce qu'on appelle Opcodes), avant qu'ils ne soient exécutés. C'est ce que vous pouvez remarquer en tant que programmeur quand l'interpréteur Perl s'interrompt avant l'exécution, dès que le script contient des erreurs de syntaxe. À l'aide de la fonction eval vous pouvez cependant appeler l'interpréteur Perl au cours d'un script et lui faire interpréter du code Perl quelconque pendant l'exécution du script. En d'autres termes, un script Perl peut de cette façon écrire lui même des scripts Perl et incorporer leur exécution dans sa propre exécution. Dans la création de code, des contenus de variables que le script gère peuvent bien sûr être repris.
Attend comme paramètre:
1. soit une chaîne de caractères qui contient du code Perl, soit un bloc d'instructions dans des parenthèses accolades, comparable à un bloc d'instructions dans un sous-programme ou à l'intérieur d'une requête if.
La différence entre les deux possibilités réside en ce qu'une chaîne de caractères transmise n'est effectivement compilée qu'à l'exécution, alors qu'il est tenu compte du bloc d'instructions dans la compilation interne préliminaire. Ainsi par exemple des erreurs graves qui mènent à l'interruption du script sont-elles déjà reconnues lors de la compilation en ce qui concerne la transmission d'un bloc d'instructions mais seulement à l'exécution en ce qui concerne la transmission d'une chaîne de caractères.
Renvoie le résultat de la dernière instruction exécutée dans la chaîne de caractères transmise ou dans le bloc d'instructions transmis. En ca d'erreur undef est renvoyé, et le message de l'erreur survenue peut être consulté par la variable prédéfinie $@ .
#!/usr/bin/perl -w
use strict;
use CGI::Carp qw(fatalsToBrowser);
my $resultat_calcul = eval($ENV{'QUERY_STRING'});
print "Content-type: text/html\n\n";
print '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">', "\n";
print "<html><head><title>Sortie du test</title></head><body>\n";
print "Le résultat de l'opération de calcul transmise est <b>$resultat_calcul</b><br>\n";
print "</body></html>\n";
|
Le script attend lors de son appel la transmission d'un paramètre qui est noté par l'URI derrière un point d'interrogation. Le paramètre transmis consiste en une opération de calcul. Il peut aussi s'agir d'expressions de calculs complexes avec parenthèses, par exemple ((6+7)*4)+(5/7). Seuls les espaces ne sont pas autorisés dans cet exemple de script simple étant donné qu'ils sont reformatés lors de leur transmission dans la ligne d'URI.
Par la variable d'environnement CGI $ENV{'QUERY_STRING'} le script peut accéder à l'opération de calcul transmise. Il transmet aussitôt la variable d'environnement à la fonction eval. Celle-ci transmet à son tour la chaîne de caractères transmise, donc l'opération de calcul lors de l'exécution à l'interpréteur Perl. La valeur de cette instruction est renvoyée et c'est dans notre cas simplement le résultat de l'opération, tel que Perl le sauvegarderait dans une scalaire si on lui affectait cette opération de calcul.
Pour le contrôle, le script envoie du code HTML au navigateur et sort le résultat de l'opération.
Les scripts comme dans l'exemple ci-dessus peuvent être extrêmement dangereux. N'en utilisez jamais comme scripts accessibles au public! Car le code transmis que le script reçoit de l'utilisateur est exécuté sans pitié. Si l'utilisateur est quelqu'un qui s'y connaît, il peut transmettre à la place de l'opération de calcul requise, un appel de system avec lequel toute une arborescence de répertoires est effacée ou le disque dur est formaté.
#!/usr/bin/perl -w
use strict;
use CGI::Carp qw(fatalsToBrowser);
my $nombre_1 = int(rand(50));
my $nombre_2 = int(rand(5));
my $resultat;
eval { $resultat = $nombre_1 / $nombre_2; };
print "Content-type: text/html\n\n";
print '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">', "\n";
print "<html><head><title>Sortie du test</title></head><body>\n";
if($@) {
print "L'erreur suivante est survenue: $@\n";
}
else {
print "$nombre_1 divisé par $nombre_2 donne $resultat\n";
}
print "</body></html>\n";
|
Dans cet exemple, la fonction eval est utilisée, comme elle l'est souvent dans la pratique pour la capture d'erreurs. Le script recherche avec rand deux nombres aléatoires $nombre_1 et $nombre_2. Ensuite il divise nombre 1 par nombre 2. Étant donné cependant que pour les nombres aléatoires recherchés la valeur 0 peut également être trouvée, une erreur grave surviendrait si nombre 2 avait cette valeur. Car une division par 0 mène sur tous les systèmes d'ordinateurs à une erreur. Le script incorpore pour cette raison l'instruction avec la division dans un bloc eval. Au cas où nombre 2 a effectivement la valeur 0, une interruption a lieu et le message d'erreur généré par Perl figure ensuite dans la variable prédéfinie $@.
L'exemple envoie du code HTML au navigateur. Ce faisant il demande si $@ a un contenu. Si oui, l'erreur est sortie. Si non, le résultat de la division effectuée est sorti.
|
|
Termine le script et renvoie une valeur au processus appelant.
Attend comme paramètre:
1. (facultatif) une valeur à renvoyer. Les valeurs usuelles qui sont reconnues également au plus tôt par des processus appelants étrangers sont 0 pour "terminé avec succès" et 1 pour "terminé avec erreurs". Si vous ne mentionnez aucun paramètre, c'est automatiquement 0 qui est utilisé.
#!/usr/bin/perl -w
use strict;
use CGI::Carp qw(fatalsToBrowser);
if($ENV{'QUERY_STRING'} eq "") {
HTML_Output("Nom d'utilisateur attendu à l'appel!");
exit(1);
}
else {
HTML_Output("Hello $ENV{'QUERY_STRING'}, Comment ça va?");
exit(0);
}
sub HTML_Output {
print "Content-type: text/html\n\n";
print '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">', "\n";
print "<html><head><title>Sortie du test</title></head><body>\n";
print "$_[0]\n";
print "</body></html>\n";
}
|
À l'appel du script, la transmission d'un paramètre est attendue qui est noté à l'appel par l'URI derrière un point d'interrogation. Le paramètre transmis comprend un nom d'utilisateur. Par l'estimation de la variable d'environnement CGI $ENV{'QUERY_STRING'} le script accède au nom transmis. Si la variable d'environnement CGI est vide (""), aucun nom n'a été transmis, Dans ce cas le script appelle le sous-programme HTML_Output et lui fait envoyer un message d'erreur au navigateur. Ensuite, le script est terminé avec exit(1). Dans le cas contraire, si tout est en ordre et qu'un nom a été transmis, le script appelle également HTML_Output mais cette fois cependant avec une salutation gentille de l'utilisateur. Dans ce cas là, le script se termine ensuite avec exit(0).
Il n'est pas de bon ton en programmation d'utiliser exit dans des sous-programmes. Si le script reconnaît des cas d'erreurs dans ces parties de programme, il doit plutôt renvoyer une valeur avec return , qui est reconnue en tant que telle dans la partie globale du script et doit conduire à cet endroit à un appel de exit.
|
|
Restreint la validité de la valeur d'une variable (qu'il s'agisse d'une scalaire, d'une liste ou d'un hash etc...) à une validité locale. La limitation peut se rapporter à un bloc d'instructions ou à un passage qui est appelé à partir de ce bloc d'instructions. S'il existe une variable du même nom en dehors du bloc, une nouvelle valeur lui est affectée temporairement à l'intérieur du bloc d'instructions. Vous pouvez appliquer cette fonction à la première introduction, donc à la déclaration de la variable.
Ne perdez pas de vue que local ne crée pas vraiment une variable locale mais seulement une variable globale avec une valeur valable localement. N'utilisez donc local que dans des cas exceptionnels justifiés! Des "vraies" variables valables localement sont déclarées avec my.
Attend comme paramètre:
1. une variable à laquelle doit être affectée temporairement une nouvelle valeur.
#!/usr/bin/perl -w
use strict;
use CGI::Carp qw(fatalsToBrowser);
use vars '$nombre_1';
print "Content-type: text/html\n\n";
print '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">', "\n";
print "<html><head><title>Sortie du test</title></head><body>\n";
my $resultat = sous_programme_1();
print "$resultat\n";
print "</body></html>\n";
sub sous_programme_1 {
local $nombre_1 = 10;
$nombre_1 = $nombre_1 * 2;
$nombre_2 = sous_programme_2();
return($nombre_1 + $nombre_2);
}
sub sous_programme_2 {
return($nombre_1 + 100);
}
|
L'exemple définit au début une scalaire $nombre_1. C'est une variable globale, valide partout et qui peut être modifiée à tout endroit du script. L'exemple contient cependant aussi plus bas un sous-programme nommé sous_programme_1. Dans celui-ci qui pour Perl représente un bloc d'instructions, une autre valeur pour le sous-programme sous_programme_1 est affectée à la variable globale avec local $nombre_1, à savoir 10. Si local manquait, alors une nouvelle valeur serait tout simplement affectée à la variable globale $nombre_1.
$nombre_1 est multiplié par 2 dans l'instruction qui suit immédiatement. Après quoi la valeur 20 figure dans $nombre_1, étant donné que la multiplication est faite avec la valeur temporaire 10.
À partir de sous_programme_1 est ensuite appelé sous_programme_2. Là est encore employée la variable $nombre_1. À cet instant dans le déroulement du script, la valeur globale 5 de la variable $nombre_1 est toujours remplacée par la valeur temporaire 20. Étant donné qu'elle est également valide dans les passages qui sont appelés à partir de sous_programme_1 cette valeur continue à être utilisée à l'intérieur de sous_programme_2 (ici la différence avec la fonction my est évidente) . À la valeur actuelle 20 est ajouté 100. La valeur que sous_programme_2 renvoie avec return, est donc 120.
sous_programme_1 renvoie après l'appel de sous_programme_2 de la même façon le résultat d'une addition à la commande appelante. Étant donné que $nombre_2 a la valeur 120 , c'est donc la valeur 140 qui est renvoyée.
Dans le programme principal, l'exemple envoie du code HTML au navigateur. Ce faisant sous_programme_1 est appelé et la valeur qu'il renvoie est sauvegardée dans la scalaire $resultat. Pour le contrôle, le résultat est sorti.
|
|
Restreint le domaine de validité d'une variable (qu'il s'agisse d'une scalaire, d'une liste ou d'un hash etc...) à un espace de nommage ou à un bloc d'instructions. Si une variable du même nom existe en dehors du bloc, elle ne sera pas touchée. Vous pouvez appliquer cette fonction lors de la définition d'une variable.
Attend comme paramètre:
1. une variable dont le domaine de validité doit être restreint.
#!/usr/bin/perl -w
use strict;
use CGI::Carp qw(fatalsToBrowser);
use vars qw($nombre_1);
$nombre_1 = 1;
print "Content-type: text/html\n\n";
print '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">', "\n";
print "<html><head><title>Sortie du test</title></head><body>\n";
my $resultat = sous_programme_1();
print "$resultat\n";
print "</body></html>\n";
sub sous_programme_1 {
my $nombre_1 = 10;
my $nombre_2 = sous_programme_2();
return($nombre_1 + $nombre_2);
}
sub sous_programme_2 {
return($nombre_1 + 100);
}
|
L'exemple définit au début une scalaire $nombre_1. C'est une variable globale, valide partout et qui peut être modifiée à tout endroit du script. La déclaration a lieu avec le module standard vars. La raison en est que l'emploi de use strict ne permet sinon aucune déclaration de variables globales et génèrerait une erreur. Vous voyez dans l'exemple comment le module vars est mis en œuvre. Incorporé avec use, figure dans la parenthèse derrière qw le nom $nombre_1, donc le nom de la variable qui doit être déclarée globalement. Dans la parenthèse derrière qw vous pouvez aussi mentionner en tant que liste, plusieurs variables globales séparées par des espaces.
Le script en exemple contient aussi plus bas un sous-programme nommé sous_programme_1. Dans celui-ci qui pour Perl représente un bloc d'instructions, est déclarée une variable avec my $nombre_1 et elle porte le même nom que la variable globale. Par l'application de my il s'agit cependant d'une nouvelle variable distincte qui est initialisée avec la valeur 10 . Si my manquait, alors une nouvelle valeur serait tout simplement affectée à la variable globale $nombre_1.
À partir de sous_programme_1 est ensuite appelé sous_programme_2. . Là est encore employée la variable $nombre_1. À cet instant dans le déroulement du script, les deux variables $nombre_1 existent. Étant donné que celle qui a été déclarée dans sous_programme_1, n'est cependant valide que là, c'est à nouveau la variable globale dont il est question dans sous_programme_2. À sa valeur 1 est ajouté 100. la valeur que sous_programme_2 retourne avec return est donc 101.
sous_programme_1 renvoie de la même façon après l'appel de sous_programme_2 le résultat d'une addition à la commande appelante. Dans ce cas il est à nouveau question avec $nombre_1 de la variable qui a été déclarée dans le même bloc, donc à l'intérieur de sous_programme_1, et qui a pour valeur 10. Étant donné que $nombre_2 a pour valeur 101, c'est donc la valeur 111 qui est sortie.
Dans le programme principal, l'exemple envoie du code HTML au navigateur. Ce faisant sous_programme_1 est appelé et la valeur qu'il renvoie est sauvegardée dans la scalaire $resultat. Pour le contrôle, le résultat est sorti.
|
|
Transforme une chaîne de caractères de telle façon que tous les caractères exceptés A à Z, a à z, 0 à 9 et le tiret de soulignement _ soient masqués par une barre oblique inversée \.
Attend comme paramètre:
1. une chaîne de caractères qui doit être transformée.
Renvoie la chaîne de caractères transformée.
#!/usr/bin/perl -w use strict; use CGI::Carp qw(fatalsToBrowser); print "Content-type: text/html\n\n"; print '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">', "\n"; print "<html><head><title>Sortie du test</title></head><body>\n"; my $texte_normal = "+++Test+++"; my $longueur_normale = length($texte_normal); my $texte_quotemeta = quotemeta($texte_normal); my $longueur_quotemeta = length($texte_quotemeta); print "<b>$texte_normal</b> a été transformé en <b>$texte_quotemeta</b><br>\n"; print "Longueur du texte avant : <b>$longueur_normale</b> caractères<br>\n"; print "Longueur du texte maintenant: <b>$longueur_quotemeta</b> caractères\n"; print "</body></html>\n"; |
L'exemple envoie du code HTML au navigateur. Ce faisant, il démontre la façon d'agir de quotemeta. Une scalaire nommée $texte_normal qui se voit affecter, tout d'abord une valeur, qui contient outre le mot "Test" différents signes plus. Par ailleurs la longueur de la chaîne de caractères est recherchée avec length . Par l'application qui suit de la fonction quotemeta sur $texte_normal les signes plus sont masqués. La valeur renvoyée par la fonction est sauvegardée dans une nouvelle scalaire nommée $texte_quotemeta. La longueur de celle-ci est également recherchée avec length. Pour le contrôle, le script sort toutes les données trouvées. La version masquée compte 6 caractères supplémentaires étant donné que chaque signe plus a été masqué.
|
|
Renvoie une valeur à l'instruction qui a appelé le sous-programme.
Attend comme paramètre:
1. (facultatif) une valeur qui doit être renvoyée. Il peut s'agir d'un nombre, d'une chaîne de caractères ou d'une variable quelconque (même d'une liste complète ou d'un hash. Si aucun paramètre n'est transmis, la sous-routine est simplement quittée et selon le dernier contexte exécuté, c'est une liste vide ou une scalaire avec la valeur undefined qui est renvoyée.
#!/usr/bin/perl -w
use strict;
use CGI::Carp qw(fatalsToBrowser);
print "Content-type: text/html\n\n";
print '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">', "\n";
print "<html><head><title>Sortie du test</title></head><body>\n";
my $sortie = gras("une affaire importante");
print "<p>$sortie</p>\n";
$sortie = italique("une affaire plus importante encore");
$sortie = gras($sortie);
print "<p>$sortie</p>\n";
print "</body></html>\n";
sub gras {
my $caracteres_gras = "<b>$_[0]</b>";
return $caracteres_gras;
}
sub italique {
my $texte_italique = "<i>$_[0]</i>";
return $texte_italique;
}
|
L'exemple contient deux sous-programmes nommés gras et italique. Dans les deux sous-programmes la transmission d'un paramètre est attendue; celui-ci figure dans la liste prédéfinie pour les paramètres transmis (@_) en première place ($_[0]). Le paramètre transmis est placé dans des repères HTML pour caractères gras et pour italique. Les scalaires $caracteres_gras ou bien $texte_italique, qui sauvegardent cette construction sont ensuite renvoyées avec return .
Le script envoie du code HTML au navigateur. Pendant la sortie, il appelle les deux sous-programmes. La valeur renvoyée est sauvegardée respectivement dans la scalaire $sortie. Dans le deuxième cas, ce sont même les deux sous-programmes qui sont appelés l'un après l'autre. Ce qui fait que le texte transmis est d'abord en italique puis en caractères gras, donc finalement en caractères gras et en italique. Pour le contrôle, les constructions HTML sont sorties.
Les sous-programmes renvoient aussi quelque chose, même s'ils ne sont pas quittés avec return. Si par exemple vous appelez un sous-programme comme suit:
$sortie = Test();
et que le sous programme ressemble à ceci:
sub Test { $x = 1; }
alors est sauvegardée ensuite dans $sortie la valeur 1.
|
|
Attend comme paramètre:
1. une expression quelconque. Il peut s'agir d'une variable, d'un appel de fonction, d'un calcul, d'une affectation etc....
Renvoie la valeur que donne l'expression transmise dans un contexte scalaire.
#!/usr/bin/perl -w
use strict;
use CGI::Carp qw(fatalsToBrowser);
print "Content-type: text/html\n\n";
print '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">', "\n";
print "<html><head><title>Sortie du test</title></head><body>\n";
my $singulier = "une table";
my @pluriel = ("une table","encore une table");
my $sortie_1 = scalar($singulier);
my $sortie_2 = scalar(@pluriel);
my $sortie_3 = scalar(time() > 900000000 ? 1 : 0);
print "sortie 1: $sortie_1<br>\n";
print "sortie 2: $sortie_2<br>\n";
print "sortie 3: $sortie_3\n";
print "</body></html>\n";
|
L'exemple envoie du code HTML au navigateur. Ce faisant, il définit une scalaire nommée $singulier et une liste nommée @pluriel. Sur l'une et l'autre, la fonction scalar est appliquée. La valeur scalaire renvoyée est sauvegardée dans les scalaires $sortie_1 et $sortie_2. Par ailleurs est définie une troisième scalaire $sortie_3, à laquelle le contexte scalaire d'une instruction plus complexe est renvoyé. Dans l'instruction est recherché si la valeur renvoyée par la fonction time est plus grande que 900000000. Si c'est le cas 1 est renvoyé, sinon, c'est 0 qui est renvoyé. Finalement, le script sort les 3 valeurs trouvées.
$sortie_1 sort simplement le contenu de la scalaire $singulier, donc une table. Que l'expression évaluée soit une scalaire ne change rien dans un contexte scalaire à la valeur renvoyée.
$sortie_2 sort un nombre, à savoir 2. La raison en est que l'interprétation scalaire d'une liste, dans l'exemple la liste @pluriel, trouve le nombre d'éléments qui sont contenus dans cette liste.
$sortie_3 sort 1 ou 0, selon la valeur retournée par time. Étant donné que 1 et 0 sont des valeurs distinctes normales, le contexte scalaire est déjà observé.
|
|
N'attend aucun paramètre
Renvoie 1 ou TRUE, si le programme appelant ou le sous-programme appelant attend un contexte de liste et 0 ou FALSE, si un contexte scalaire est attendu. Renvoie undef, quand absolument aucun contexte n'est attendu (ce qu'on appelle en anglais void context).
#!/usr/bin/perl -w
use strict;
use CGI::Carp qw(fatalsToBrowser);
print "Content-type: text/html\n\n";
print '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">', "\n";
print "<html><head><title>Sortie du test</title></head><body>\n";
my @nombres = (1,2,3,4,5);
my $somme_normale = rechercher_somme(@nombres);
print "La somme normale de 1,2,3,4,5 est <b>$somme_normale</b><br>\n";
my @somme_cumulee = rechercher_somme(@nombres);
print "Die somme_cumulee von 1,2,3,4,5 sind <b>@somme_cumulee</b><br>\n";
print "</body></html>\n";
sub rechercher_somme {
if(wantarray) {
my @somme = @_;
my $valeur;
foreach my $somme (@somme) {
$somme = $valeur += $somme;
}
return @somme;
}
else {
my $valeur;
foreach my $somme (@_) {
$valeur += $somme;
}
return $valeur;
}
}
|
L'exemple contient un sous-programme nommé rechercher_somme. La fonction attend une liste de nombres comme paramètre pour lesquels une requête peut être faite par la liste de paramètres @_. À l'intérieur de la fonction, il est demandé avec if(wantarray), si l'instruction qui appelle le sous-programme attend une liste ou une scalaire comme valeur renvoyée. Si une liste est attendue c'est l'embranchement if qui est exécuté. Si une scalaire est attendue, c'est l'embranchement else. Dans l'embranchement if est noté un algorithme qui recherche les sommes cumulées des nombres transmis. Les sommes cumulées sont tenues dans une liste nommée @somme. Cette liste est renvoyée à la fin. Dans l'embranchement else par contre, la fonction ne recherche que la somme des nombres transmis et tient le résultat dans la scalaire $valeur qu'elle retourne à la fin.
Dans le programme principal, l'exemple envoie du code HTML au navigateur. Ce faisant, le sous-programme rechercher_somme est appelé en tout deux fois. Une fois, la valeur renvoyée est sauvegardée dans une scalaire nommée $somme_normale, et la deuxième fois dans une liste nommée @somme_cumulee. Ainsi lors du premier appel du sous-programme c'est l'embranchement else qui est exécuté et lors du deuxième appel, l'embranchement if. Pour le contrôle le script sort les résultats respectivement obtenus.
|
|
Écrit des avertissements sur la sortie standard d'erreur STDERR, sans mettre fin au script (à la différence de die). Pour le port CGI d'un serveur WWW la sortie standard d'erreur est la plupart du temps un fichier Log, dans lequel ces messages d'erreur sont réunis. Recherchez le cas échéant dans la documentation du serveur Web où et comment les messages d'erreur sont recensés.
Attend comme paramètre:
1. Une liste avec les avertissements qui doivent être écrits sur la sortie standard d'erreur STDERR.
#!/usr/bin/perl -w
use strict;
use CGI::Carp qw(fatalsToBrowser);
my $Daten = $ENV{'QUERY_STRING'};
print "Content-type: text/html\n\n";
print '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">', "\n";
print "<html><head><title>Sortie du test</title></head><body>\n";
if(! -e "/usr/web/temp/idx.txt") {
warn("idx.txt non trouvé. fichier créé à nouveau pour cette raison\n");
open(FILE,">/usr/web/temp/idx.txt");
print FILE "$donnees\n";
}
else {
open(FILE,">>/usr/web/temp/idx.txt");
print FILE "$donnees\n";
}
print "<b>inscrits dans le fichier:</b> $donnees\n";
close(FILE);
print "</body></html>\n";
|
Le script attend lors de son appel la transmission d'un paramètre qui est noté par l'URI derrière un point d'interrogation. Le paramètre transmis consiste en un nom d'utilisateur. Par l'estimation de variable d'environnement CGI $ENV{'QUERY_STRING'} le script accède aux données transmises.
Le script envoie du code HTML au navigateur. Pendant ce temps, il essaie avec open d'ouvrir un fichier nommé /usr/web/temp/idx.txt, pour y écrire à la fin les données transmises. Au cas où le fichier n'existe pas, il est à nouveau créé dans l'embranchement if (au cas tout au moins où le répertoire /usr/web/temp existe déjà), mais un avertissement correspondant est écrit avec warn sur la sortie standard d'erreur. Pour le contrôle, il est encore transmis au navigateur quelles données ont été écrites dans le fichier.
La requête if vérifie avec l' opérateur de test fichier pour fichiers et répertoires -e, si le fichier existe déjà. C'est ce qui va conditionner la réaction du script.
|
| |
 |
Fonctions pour les date et heure
|
 |
Fonctions pour les calculs
|
| SELFHTML/Aides à la navigation CGI/Perl Fonctions Perl |
© 2001 Stefan Münz / © 2003 Traduction 
Serge François, 13405@free.fr selfhtml@fr.selfhtml.org