SELFHTML/Aides à la navigation CGI/Perl Fonctions Perl| SELFHTML/Aides à la navigation CGI/Perl Fonctions Perl |
 |
Fonctions pour les chaînes de caractères |
|
|
 | |
Pour comprendre les fonctions réunies ici, vous devez connaître les remarques générales sur les 
Chaînes de caractères (Strings) en Perl.
|
Retire le dernier signe du chaîne de caractères. Cela peut être intéressant avant tout pour continuer à travailler sur des chaînes de caractères qui comprennent un signe de fin, en règle générale un signe de retour à la ligne \n. À la différence de la fonction chop, qui retire le dernier caractère dans tous les cas, peu importe de quoi il s'agit, la fonction chomp ne retire que les signes qui sont contenus dans la Variable prédéfinie en Perl $/. Par défaut, seul le signe de passage à la ligne \n est sauvegardé dans cette variable. Si une chaîne de caractères ne se terminait pas par ce caractère de contrôle, l'application de chomp n'aurait aucun effet à l'inverse de chop.
Attend comme paramètre:
1. la liste de chaînes de caractères sur lesquelles la fonction doit être appliquée. Au lieu d'une liste, une chaîne de caractères distincte ou une scalaire avec une chaîne de caractères peut être transmise.
Renvoie le nombre de signes ayant été retirés.
mode con codepage prepare=((850) C:\WINDOWS\COMMAND\ega.cpi) mode con codepage select=850 keyb gr,,C:\WINDOWS\COMMAND\keyboard.sys SET PATH=d:\PERL\BIN;"%PATH%" |
#!/usr/bin/perl -w use strict; use CGI::Carp qw(fatalsToBrowser); open(AUTOEXEC, "<c:/autoexec.bat") || die "Erreur survenue: $!"; my @lignes = <AUTOEXEC>; close(AUTOEXEC); chomp(@lignes); 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 "<pre>\n"; print "@lignes"; print "</pre>\n"; print "</body></html>\n"; |
L'exemple montre dans la première partie un exemple de fichier texte typique avec des lignes, ici le fichier autoexec.bat, tel qu'on le trouve sur les ordinateurs DOS/Windows. Dans le script CGI le fichier est lu et copié dans la liste @lignes. Ensuite la fonction chomp est appliquée à la liste @lignes. cela permet de retirer de chaque ligne, le signe de passage à la ligne qui la termine. Pour le contrôle, le script sort à la fin le code HTML dans le navigateur. À l'intérieur d'un passage <pre> où tout est sortie comme noté, la liste @lignes est sortie. Comme tous les signes de passage à la ligne ont été retirés, les éléments de la liste n'apparaissent plus comme des lignes distinctes mais comme une suite de caractères.
|
|
Retire le dernier signe d'une chaîne de caractères. À la différence de la fonction chomp, chop retire le dernier caractère dans tous les cas, peu importe de quoi il s'agit.
Attend comme paramètre:
1. une variable sur laquelle la fonction doit être appliquée. Une liste peut aussi être transmise en alternative. Si une liste est transmise, chop retourne le signe retiré du dernier élément de la liste.
Retourne le signe retiré.
Vous trouverez de plus amples explications sur la différence entre chop et chomp, ainsi qu'un exemple complet avec explications dans la description de chomp.
|
|
Recherche le caractère correspondant à une valeur numérique. Seuls les signes dont la valeur ASCII est supérieure à 32 peuvent être représentés étant donné que les signes dont la valeur est inférieure à 32 sont ce qu'on appelle les caractères de contrôle qui ne peuvent pas, en règle générale, être représentés à l'écran.
La fonction inverse est ord.
Attend comme paramètre:
1. la valeur ASCII désirée comme nombre.
Renvoie le caractère correspondant.
#!/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";
print "<table border=\"1\" bgcolor=\"#FFFFE0\">\n";
my $valeur_signe = 0;
my $signe_ASCII = "";
for(my $i=0;$i<16;$i++) {
print "<tr>\n";
for(my $j=0;$j<8;$j++) {
$signe_ASCII = chr($valeur_signe);
print "<td>$valeur_signe = $signe_ASCII</td>\n";
$valeur_signe++;
}
print "</tr>\n";
}
print "</table>\n";
print "</body></html>\n";
|
L'exemple établit, dans deux boucles boucle for imbriquées l'une dans l'autre, un tableau HTML avec 16 rangées à 8 colonnes. Dans chaque cellule ainsi créée sont sortis un caractère ASCII et sa valeur. Pour cela la fonction chr est appliquée, avant l'écriture dans la cellule de tableau actuelle, sur la valeur actuelle de la scalaire $valeur_signe, qui est incrémentée de 1 à chaque passage de boucle et qui accepte par les deux boucles et dans l'ordre, tous les chiffres entre 0 et 127. La valeur renvoyée, donc le caractère ASCII, est sauvegardé à chaque fois dans la scalaire $signe_ASCII. Les deux scalaires sont ensuite sorties dans chaque cellule du tableau de façon à ce que la correspondance entre la valeur ASCII et le caractère ASCII soit bien claire.
|
|
Cette fonction vous permet de crypter une chaîne de caractères. Pour cela, la chaîne de caractères elle-même est nécessaire ainsi qu'une deuxième chaîne de caractères qui sert de "sel dans la soupe" (en anglais salt).
La fonction crypt n'effectue le cryptage que dans un sens. Une méthode de décryptage correspondante n'est pas connue. crypt ne se prête pas pour cette raison pour réaliser des processus de codage et de décodage.
crypt correspond au programme système du même nom sous Unix et à la fonction du même nom en C. En relation avec les pages Web, crypt est utilisé par exemple pour la protection des répertoires et des fichiers avec mot de passe, pour sauvegarder de façon cryptée les mots de passe des accès autorisés.
Attend comme paramètre:
1. la chaîne de caractères à crypter.
2. le "sel dans la soupe", une chaîne de caractères qui doit comporter deux caractères librement choisis.
Renvoie la chaîne de caractères cryptée.
#!/usr/bin/perl -w
use strict;
use CGI::Carp qw(fatalsToBrowser);
my $Input = $ENV{'QUERY_STRING'};
my ($chaine, $sel) = split(/\+/,$Input);
my $chaine_cryptee = crypt($chaine,$sel);
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 "la chaîne de caractères <b>$chaine</b> sous forme codée donne: <b>$chaine_cryptee</b>\n";
print "</body></html>\n";
|
Le script CGI en exemple attend la transmission d'un paramètre qui, lors de l'appel est noté par l'URI derrière un point d'interrogation. Le paramètre transmis comprend la chaîne de caractères à cryptée et le "sel dans la soupe", séparé par un signe plus. Exemple:
http://localhost/cgi-bin/test.pl?Serge+kn.
Le script en exemple recherche le paramètre transmis dans la Variable d'environnement CGI QUERY_STRING et en sauvegarde la valeur dans la scalaire $input. Pour séparer les paramètres transmis au signe plus (ici donc séparer la chaîne de caractères à crypter et le "sel dans la soupe" l'une de l'autre), la fonction split est appliquée, et sauvegarde le résultat dans une liste constituée des deux scalaires $chaine et $sel. Enfin la fonction crypt à laquelle les deux scalaires sont transmises comme paramètres, est appliquée. La valeur renvoyée, donc la chaîne de caractères cryptée est sauvegardée dans la scalaire $chaine_cryptee. Pour le contrôle, le script sort la chaîne à crypter et le résultat du cryptage.
|
|
Cette fonction recherche dans une chaîne de caractères, un fragment de chaîne de caractères quelconque, sans expression régulière toutefois. Vous pouvez donc rechercher Sex-Appeal dans une ligne de texte mais pas Sex.*.
Attend comme paramètre:
1. la chaîne de caractères dans laquelle la recherche doit se faire,
2. la chaîne de caractères qu'il faut y rechercher,
3. (facultatif) la position du signe à partir de laquelle la recherche doit commencer, par exemple 8 pour "à partir du 9 ème signe". Si vous ne mentionnez pas le troisième paramètre, la recherche s'effectue dès le début de la chaîne de caractères.
Renvoie la position du signe où le fragment de chaîne de caractères désiré a été trouvé. S'il n
n'a pas été trouvé -1 est renvoyé.
#!/usr/bin/perl -w
use strict;
use CGI::Carp qw(fatalsToBrowser);
my $phrase = "dans cette phrase il est question d'amour.";
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(index($phrase,"amour") >= 0) {
print "dans cette phrase il est question d'amour\n";
}
else {
print "dans cette phrase il n'est malheureusement pas question d'amour\n";
}
print "</body></html>\n";
|
L'exemple définit une scalaire nommée $phrase et lui affecte une valeur. Le script envoie du code HTML au navigateur appelant. Avec la fonction index il recherche s'il est question d'amour dans la scalaire $phrase. C'est le cas si la valeur renvoyée par la fonction est plus grande ou égale à 0. Dans l'exemple ci-dessus, le script aboutit dans l'embranchement if parce que dans la phrase où s'effectue la recherche il est question d'amour.
|
|
Transforme les majuscules en minuscules en laissant les minuscules et tous les autres signes inchangés. La fonction inverse correspondante pour les majuscules est uc.
Attend comme paramètre:
1. la chaîne de caractères qui doit être traitée.
Renvoie la chaîne de caractères après traitement.
#!/usr/bin/perl -w
use strict;
use CGI::Carp qw(fatalsToBrowser);
opendir(DIR, "c:/windows");
my @elements = readdir(DIR);
closedir(DIR);
foreach my $element (@elements) {
$element = lc($element);
$element = $element."\n";
}
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 "<pre>\n";
print "@elements";
print "</pre>\n";
print "</body></html>\n";
|
L'exemple lit sur l'ordinateur avec un système d'exploitation Windows le répertoire habituel Windows (les commandes correspondantes pour le faire sont opendir, readdir) et closedir. Dans se répertoire, se trouvent en principe une quantité de fichiers et de sous-répertoires qui reçoivent indifféremment des majuscules et des minuscules, en partie également parce qu'ils font partie des anciens programmes en 16 bits. Sur chaque élément de la liste @elements, dans laquelle le contenu du répertoire a été copié, la fonction lc et ensuite appliquée dans une boucle for. La valeur renvoyée est sauvegardée dans la même variable actuelle de boucle $element qui est aussi transmise comme chaîne de caractères à traiter.
L'ajout du signe de passage à la ligne dans la même boucle for n'est en fait que pour la sortie qui va suivre. La sortie crée la liste complète des éléments de répertoire lus et traités. Tous les éléments ne contiennent plus que des minuscules.
|
|
Transforme le premier signe d'une chaîne de caractères en minuscule dans la mesure où il s'agit d'une majuscule. La fonction correspondante pour les majuscules est ucfirst.
Attend comme paramètre:
1. la chaîne de caractères qui doit être traitée.
Renvoie la chaîne de caractères après traitement.
#!/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 $mot = "Roubaix"; print lcfirst($mot); print "</body></html>\n"; |
L'exemple sort simplement un mot, Avant que le mot ne soit sorti, la fonction lcfirst lui est appliquée. La majuscule du début est ainsi transformée en minuscule.
|
|
Attend comme paramètre:
1. la chaîne de caractères souhaitée.
Renvoie le nombre de caractères constituant la chaîne de caractères.
#!/usr/bin/perl -w
use strict;
use CGI::Carp qw(fatalsToBrowser);
my $URI = $ENV{'QUERY_STRING'};
my $longueur = length($URI);
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 "<a href=\"$URI\">$URI</a> a une longueur de $longueur caractès!\n";
print "</body></html>\n";
|
Le script CGI en exemple attend la transmission d'un paramètre qui est noté derrière un point d'interrogation lors de l'appel par l'URI. Le paramètre transmis doit lui-même contenir une URI. Exemple:
http://localhost/cgi-bin/test.pl?http://actuel.fr.selfhtml.org/.
L'exemple recherche avec length la longueur de l'adresse transmise et sort du code HTML avec un lien à l'adresse et mention du nombre de caractères.
|
|
Recherche pour une signe la valeur ASCII correspondante entre 0 rt 127.
La fonction inverse est chr.
Attend comme paramètre:
1. le signe désiré.
Renvoie la valeur ASCII correspondante.
#!/usr/bin/perl -w
use strict;
use CGI::Carp qw(fatalsToBrowser);
my $chiffre_magique = "155";
my $longueur = length($chiffre_magique);
my $total_horizontal = 0;
for(my $i=0; $i<$longueur; $i++) {
my $signe = substr($chiffre_magique, $i, 1);
$total_horizontal = $total_horizontal + int(ord($signe));
}
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 total horizontal des valeurs ASCII des signes du nombre $chiffre_magique s'élève à $total_horizontal\n";
print "</body></html>\n";
|
L'exemple définit un "chiffre magique" 155. "Magique" il l'est pour la simple raison qu'il est constitué des signes "1", "5" et encore "5", et parce que le total des valeurs ASCII de ces trois signes donne 155. Car le 1 a 49 pour valeur ASCII, le 5 a la valeur ASCII 53, et que 49+53+53 donne 155. Dans une boucle for le nombre est lu chiffre par chiffre. En Perl, cela marche à l'aide de la fonction substr. Sur chacun des chiffre lus la fonction ord est appliquée. La valeur renvoyée, donc la valeur ASCII du signe traité est ajoutée à chaque passage de boucle à la valeur de la scalaire $total_horizontal. Le script renvoie pour le contrôle un résultat correspondant sous forme de code HTML.
|
|
Crée une structure de données binaire à partir d'une ou de plusieurs valeurs. L'entrée des données peut être elle-même une chaîne de caractères mais aussi par exemple une liste. Une mention supplémentaire de formatage sert à contrôler exactement le format binaire des données du résultat de la conversion à créer. Pour la mention de formatage, une syntaxe spéciale existe.
La fonction pack est utilisée par exemple pour transmettre des chaînes de caractères à une base de données dans lesquelles la base de données attend des longueurs de champs fixes. Mais aussi d'autres travaux de formatage puissants sont possibles. Ainsi par exemple les données peuvent elles être très simplement codées d'après le procédé UUencode à l'aide de pack.
Attend comme paramètre:
1. la mention de formatage,
2. l'entrée des données - une chaîne de caractères ou une liste.
Renvoie la valeur créée.
#!/usr/bin/perl -w
use strict;
use CGI::Carp qw(fatalsToBrowser);
my @enregistrement_1 = ("Anna","Lyse","07.07.1977","f","bat. 21", "Ch. 280","depuis 03/1999 assistante commerciale");
my @enregistrement_2 = ("Gaston","Quinoise","29.02.1960","m","bat. 113", "Ch. 11","Direction section développement");
my $Format = "A10 A14 A10 A1 A7 A7 A*";
my $sortie_1 = pack($Format, @enregistrement_1);
my $sortie_2 = pack($Format, @enregistrement_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";
print "<pre>\n";
print "$sortie_1\n";
print "$sortie_2\n";
print "</pre>\n";
print "</body></html>\n";
|
L'exemple envoie la sortie HTML suivante au navigateur:
Anna Lyse 07.07.1977fbat. 21 Ch. 280 depuis 03/1999 assistante commerciale Gaston Quinoise 29.02.1960mbat. 113Ch. 11 Direction section développement |
Dans l'exemple sont d'abord définies deux listes @enregistrement_1 et @enregistrement_2 avec des données sur l'employé du même genre. Les champs d'une enregistrement doivent tous être reliés à une chaîne de caractères de telle façon qu'elle puisse être sortie sur une ligne à l'écran ou écrite dans un fichier. Ici les champs doivent cependant commencer toujours à la même position dans la colonne comme il est représenté dans la sortie du résultat. Pour y arriver un chaîne de caractères nommée $Format est définie. Elle définit les largeurs des différents champs de l'enregistrement. Pour le faire, elle utilise la syntaxe spéciale pour les mentions de formatage de pack . Vous trouverez ci-dessous un tableau des mentions de formatage. Dans l'exemple est définie pour le premier champ (prénom) une largeur de 10 caractères avec A10, pour le deuxième champ (nom de famille) une largeur de 14 caractères avec A14 , et ainsi de suite pour les autres champs. Le dernier champ, mention descriptive, est défini par l'astérisque avec A* comme "aussi large que l'est le contenu du champ".
Enfin la fonction pack est appliquée deux fois, une fois sur @enregistrement_1 et ensuite sur @enregistrement_2. Dans les deux cas, la même mention de formatage est utilisée, à savoir $Format. La valeur renvoyée est sauvegardée respectivement dans les chaînes de caractères $sortie_1 ou bien $sortie_2. Ces deux chaînes de caractères sont envoyées pour contrôle comme sortie HTML au navigateur. Il est important ici de fixer la sortie dans un passage <pre>, car il n'y a que là que la représentation en colonnes peut être vue.
#!/usr/bin/perl -w
use strict;
use CGI::Carp qw(fatalsToBrowser);
my $phrase = "À Munich, en Bavière, François boit la bière dans la fête";
my $phrase_UUE = pack("u", $phrase);
print "Content-type: text/plain\n\n";
print print "La phrase '$phrase' donne après codage UU:\n$phrase_UUE";
|
L'exemple définit une phrase dans la scalaire $phrase. Sur cette scalaire est appliquée la fonction pack. La mention de formatage transmise est ici u. Ceci provoque un codage d'après le procédé UUencode. Le résultat est sauvegardé dans une nouvelle scalaire $phrase_UUE. Pour le contrôle, le résultat correspondant est envoyé au navigateur. La phrase de l'exemple donne en codage UUencode MP"!-=6YI8V@L(&5N($)A=FGH<F4L($9R86[G;VES(&)O:70@;&$@8FGH<F4@
,9&%N<R!L82!FZG1E
.
Par la mention de formatage, vous contrôlez la façon dont pack traite l'entrée des données.
|
|
|
Les expressions régulières du type m/[regexp]/g ou tout simplement /[regexp]/g peuvent rechercher dans des chaînes de caractères partout où l'expression mentionnée convient. La fonction pos donne la position dans la chaîne de caractères où il faut rechercher à laquelle la recherche continuerait si l'expression régulière était à nouveau appelée à chaque fois. Par un agencement adroit dans une boucle, vous pouvez à l'aide de cette fonction trouver toutes les positions des occurrences dans la chaîne de caractères. Vous pouvez également modifier cette valeur pour influer sur la recherche.
Attend comme paramètre:
1. la chaîne de caractères où doivent s'effectuer les recherches ou la scalaire dans laquelle elle est sauvegardée.
Retourne la prochaine position trouvée où la recherche se poursuit. Les caractères qui la précèdent correspondent au modèle de recherche.
#!/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 $phrase = "il est ce qu'il est";
my $mot_cherche = "est";
while($phrase =~ /$mot_cherche/g) {
my $occurrence = pos($phrase) - 3;
print "\Le mot cherché <b>$mot_cherche</b> est trouvé à la position $occurrence<br>\n";
}
print "</body></html>\n";
|
Le script en exemple montre comment trouver dans une chaîne de caractères toutes les occurrences d'un certain modèle de recherche et comment les rassembler. Dans l'exemple est définie une chaîne de caractères où les recherches doivent être effectuées $phrase qui se voit affecter une valeur. Le modèle qui doit être recherché dans cette phrase est défini dans la scalaire $mot_cherche. Dans une boucle while la recherche du modèle s'effectue dans la phrase. l'option g pour "global" derrière l'expression régulière est ici importante. L'exemple envoie du code HTML au navigateur. Dans la boucle, la position de chaque occurrence du modèle est sortie. Ici la fonction pos est appliquée sur la chaîne de caractères où les recherches doivent être effectuées $phrase. La valeur renvoyée est la première position après le modèle de recherche trouvé. Étant donné que l'exemple recherche un mot déterminé "est" qui comporte 3 lettres, la position de départ à laquelle le mot commence est trouvée en soustrayant 3. Le résultat est sauvegardé à chaque fois dans la scalaire $occurrence. Dans l'exemple, deux lignes en tout sont sorties, à savoir des avis où le modèle est trouvé pour les positions 3 et 16. La raison: le mot est placé deux fois dans la phrase, et la recherche aboutit deux fois sur la position qui suit, donc sur les positions 6 et 19.
|
|
Inverse une chaîne de caractères signe par signe. Au lieu d'une chaîne de caractères, vous pouvez aussi transmettre une liste, dont les éléments dont reliés à une chaîne de caractères avant la transformation.
Attend comme paramètre:
1. la chaîne de caractères ou la liste qui doit être traitée.
Renvoie une chaîne de caractères traitée.
#!/usr/bin/perl -w
use strict;
use CGI::Carp qw(fatalsToBrowser);
my $palindrome = reverse("ÉSOPE RESTE ÉLU PAR CETTE CRAPULE ET SE REPOSE");
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 "$palindrome\n";
print "</body></html>\n";
|
Dans l'exemple, la phrase classique "ÉSOPE RESTE ÉLU PAR CETTE CRAPULE ET SE REPOSE", que l'on peut aussi bien lire en arrière qu'en avant (palindrome), est utilisée pour illustrer. La fonction reverse est appliquée à cette phrase, et la valeur renvoyée est sauvegardée dans la scalaire $palindrome. Pour le contrôle, du code HTML est envoyé au navigateur, il sort la chaîne de caractères après traitement.
|
|
Crée à partir d'une chaîne de caractères, une liste de fragments de chaînes de caractères, et cela sur la base d'une expression régulière, qui définit le symbole de séparation séparant les différents fragments. Les symboles de séparation peuvent avoir une longueur quelconque et ne sont pas obligatoirement identiques à chaque occurrence.
Attend comme paramètre:
1. une expression régulière, qui définit comment la chaîne de caractères doit être scindée en différents fragments,
2. la chaîne de caractères à traiter.
Renvoie une liste des fragments extraits de la chaîne de caractères.
#!/usr/bin/perl -w use strict; use CGI::Carp qw(fatalsToBrowser); my $phrase = "Donne toi bien le bonjour chaque matin"; my @mots = split(/ /,$phrase); my $nombre = @mots; 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 "La phrase <b>$phrase</b> comprend $nombre mots\n"; print "</body></html>\n"; |
L'exemple définit une phrase. la fonction split est appliquée à cette phrase. Ici, une expression régulière est transmise comme paramètre, qui ne convient qu'aux espaces. Le deuxième paramètre transmis est la scalaire $phrase, dans laquelle la phrase est sauvegardée. La fonction scinde la phrase en différents éléments séparés les uns des autres par des espaces - dans l'exemple donc, les différents mots. Ceux-ci sont sauvegardés dans la liste @mots. Dans l'exemple, le nombre de mots doit être recherché pour le contrôle, ce qui est fait grâce à l'instruction $nombre = @mots;. L'exemple envoie ensuite du code HTML au navigateur, en sortant le nombre de mots trouvés dans la phrase.
|
|
Recherche une sous-chaîne de caractères à partir d'une chaîne de caractères à une certaine position et la remplace le cas échéant par une autre.
Attend comme paramètre:
1. la chaîne de caractères de laquelle il faut extraire,
2. la position du premier signe de la sous-chaîne de caractères souhaitée (la position du premier signe dans une chaîne de caractères est 0, la deuxième est 1 etc...),
3. (facultatif) le nombre de signes que doit comprendre la sous-chaîne de caractères souhaitée,
4. (facultatif) une chaîne de caractères de remplacement
#!/usr/bin/perl -w
use strict;
use CGI::Carp qw(fatalsToBrowser);
my $phrase = "Carpe diem!";
my $longueur_phrase = length($phrase);
my @signes;
for(my $i=0; $i<$longueur_phrase; $i++) {
$signes[$i] = substr($phrase,$i,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";
for(my $i=0; $i<$longueur_phrase; $i++) {
print "Le signe $i est: $signes[$i]<br>\n";
}
print "</body></html>\n";
|
Dans l'exemple, la fonction substr est utilisée pour sauvegarder les différents signes d'une chaîne de caractères dans une liste. Car il manque en Perl le traitement typique pour C de chaîne de caractères en tableau de signes. À la différence de C qui ne sauvegarde des chaînes de caractères que sous forme de tableau, les différents caractères d'une chaîne de caractères ne peuvent pas être adressés directement en Perl. L'exemple montre une méthode - même si elle est un peu compliquée - qui par la répétition des différents signes de la chaîne de caractères, traite donc cette dernière signe par signe.
Dans l'exemple, une scalaire $phrase est définie avec une valeur. La longueur de la phrase est sauvegardée dans la scalaire $longueur_phrase (par l'application de length). Enfin, la phrase est copiée caractère par caractère dans une boucle for dans la liste @signes. Pour ce faire, la fonction substr est appliquée de telle façon qu'un signe de la phrase est "extrait" à chaque fois. Pour le contrôle le script envoie du code HTML au navigateur dans lequel les différents signes de la phrase sont listés l'un sous l'autre.
|
|
Change les minuscules en majuscules en laissant les majuscules et tous les autres signes inchangés. La fonction inverse correspondante pour les majuscules est lc.
Attend comme paramètre:
1. la chaîne de caractères qui doit être traitée.
Renvoie la chaîne de caractères après traitement.
#!/usr/bin/perl -w use strict; use CGI::Carp qw(fatalsToBrowser); my $phrase = "J'ai envie de crier!"; $phrase = uc($phrase); 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 "$phrase\n"; print "</body></html>\n"; |
L'exemple définit une phrase écrite normalement. Mais chaque passionné d'Internet sait que l'on doit utiliser des majuscules quand on a envie de crier à quelqu'un. Pour cette raison, la fonction uc est appliquée à la phrase et sauvegarde la valeur renvoyée dans cette même scalaire qui lui a été transmise en paramètre. Pour le contrôle, du code HTML est envoyé au navigateur et sort la phrase traitée.
|
|
change le premier signe d'une chaîne de caractères en majuscule dans la mesure où il s'agit d'une minuscule. La fonction inverse correspondante pour les majuscules est lcfirst.
Attend comme paramètre:
1. la chaîne de caractères qui doit être traitée.
Renvoie la chaîne de caractères après traitement.
#!/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 $mot = "serge"; print ucfirst($mot); print "</body></html>\n"; |
L'exemple sort simplement un mot. Avant que le mot soit sorti, la fonction ucfirst y est à vrai dire appliquée. La minuscule au début est alors transformée en majuscule et change ainsi la signification du mot.
|
|
Rétablit (presque) tout ce qui a été transformé en données binaires avec la fonction pack, ou des données binaires crées autrement qui correspondent à l'un des formats correspondants.
Attend comme paramètre:
1. la mention de formatage, voir Tableau des mentions de formatage,
2. l'entrée des données.
Renvoie la liste des valeurs correspondantes.
#!/usr/bin/perl -w
use strict;
use CGI::Carp qw(fatalsToBrowser);
my $phrase = "Beam me up, Scotty";
my @signes = unpack("C*", $phrase);
my $total_horizontal = 0;
foreach(@signes) {
$total_horizontal += int($_);
}
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 total horizontal des valeurs ASCII des signes de la phrase <b>$phrase</b> est <b>$total_horizontal</b>\n";
print "</body></html>\n";
|
La mention de formatage C crée pour la fonction pack à partir de données numériques, les valeurs de signes correspondantes. Pour unpack c'est le contraire. Ici la fonction crée à partir d'une suite d'octets, qui correspond à la chaîne de caractères du codage de signes utilisé lors de l'entrée, une liste de valeurs numériques. Dans l'exemple, ceci est utilisé pour rechercher le total horizontal de toutes les valeurs ASCII de la phrase. L'exemple envoie du code HTML au navigateur en sortant le résultat.
Pour de plus amples détails sur les possibilités complexes de cette fonction voir pack.
|
| |
 |
Fonctions pour les listes et les hashes
|
 |
Travaux CGI typiques en Perl
|
| SELFHTML/Aides à la navigation CGI/Perl Fonctions Perl |
© 2001 Stefan Münz / © 2003 Traduction 
Serge François, 13405@free.fr selfhtml@fr.selfhtml.org