SELFHTML/Aides à la navigation CGI/Perl Fonctions Perl| SELFHTML/Aides à la navigation CGI/Perl Fonctions Perl |
 |
Fonctions pour les listes et les hashes |
|
|
 | |
Pour comprendre les fonctions réunies ici, vous devez connaître la signification des listes, arrays et hashes en Perl comment ils sont définis et quelles particularités il présentent. Ceci est traité dans les parties sur les 
listes et les hashes.
|
Efface une paire d'éléments quelconque d'un hash. Contrairement à la fonction undef, qui n'efface que la valeur, en laissant cependant figurer la paire d'éléments, delete retire la paire complète d'éléments.
Attend comme paramètre:
1. la clé de l'élément à effacer.
Renvoie la valeur de la paire d'éléments effacée ou bien undefined, au cas où rien n'a été effacé.
#!/usr/bin/perl -w
use strict;
use CGI::Carp qw(fatalsToBrowser);
my %couleurs_body = ("text","#000000","link","#FF0000","alink","0000FF","vlink","#990000","bgcolor","#FFFFFF");
delete $couleurs_body{'bgcolor'};
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 "text = $couleurs_body{'text'}<br>\n";
print "link = $couleurs_body{'link'}<br>\n";
print "alink = $couleurs_body{'alink'}<br>\n";
print "vlink = $couleurs_body{'vlink'}<br>\n";
print "bgcolor = $couleurs_body{'bgcolor'}\n";
print "</body></html>\n";
|
L'exemple définit un hash nommé %couleurs_body. Y sont définies les paires d'éléments pour les attributs habituels de l'élément body de HTML. À l'aide de la fonction delete la paire d'éléments complète pour bgcolor est ensuite effacée. Pour le contrôle, du code HTML est envoyé au navigateur et sort toutes les paires d'éléments. La tentative de sortir l'élément bgcolor qui n'existe plus provoque ici une erreur.
Vous pouvez également appliquer delete sur des hashes prédéfinis tels que %ENV. Ce qui a pour conséquence de modifier les variables d'environnement!
L'exemple ci dessus est peu satisfaisant dans la mesure où la sortie de bgcolor = continue à exister vide. Comment cela peut être évité, c'est ce que montre l'extension de l'exemple en relation avec la fonction exists.
|
|
Recherche la paire d'éléments suivante dans le hash et se prête bien avant tout pour traiter toutes les paires d'éléments dans une boucle.
Attend comme paramètre:
1. le hash.
Renvoie au choix soit une liste de deux éléments avec le nom et la valeur de la paire d'éléments suivante, ou bien une scalaire avec le nom de la prochaine paire d'éléments.
#!/usr/bin/perl -w
use strict;
use CGI::Carp qw(fatalsToBrowser);
my %courriel = ("expediteur","tabaluga\@dragon.net",
"Received","from smtp\@mailout.fr",
"Date", "Sat, 01 Apr 2000 01:45:35 +0200",
"X-Mailer","Mozilla 4.72 [en] (WinNT; U)",
"To","selfhtml\@fr.selfhtml.org",
"Content-Type","text/plain; charset=us-ascii");
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><pre>\n";
while (my ($nom, $valeur) = each %courriel) {
print "$nom: $valeur\n";
}
print "</pre></body></html>\n";
|
L'exemple définit un hash avec des paires d'éléments qui représentent les données d'entête typiques d'un courriel. Ensuite, l'exemple envoie du code HTML au navigateur dans lequel sont sorties toutes les paires d'éléments du hash ligne par ligne. Pour ce faire, les paires d'éléments sont traitées dans une boucle while avec each. La valeur renvoyée par each est sauvegardée, dans l'exemple, dans une liste de deux éléments my ($nom, $valeur). S'il ne figurait à cet endroit qu'une scalaire, donc par exemple $element_suivant, seul le nom de l'élément suivant y serait sauvegardé, donc par exemple expediteur, et pas la valeur correspondante (tabaluga@dragon.net). L'exemple sort à chaque boucle pour contrôle, les données trouvées.
|
|
Recherche si un nom existe dans un hash, et est en principe utilisé en relation avec une requête if.
Attend comme paramètre:
1. le nom d'élément.
Renvoie true, si le nom d'élément existe dans le hash.
#!/usr/bin/perl -w
use strict;
use CGI::Carp qw(fatalsToBrowser);
my %couleurs_body = ("text","#000000","link","#FF0000","alink","0000FF","vlink","#990000","bgcolor","#FFFFFF");
delete $couleurs_body{'bgcolor'};
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 "text = $couleurs_body{'text'}<br>\n" if exists $couleurs_body{'text'};
print "link = $couleurs_body{'link'}<br>\n" if exists $couleurs_body{'link'};
print "alink = $couleurs_body{'alink'}<br>\n" if exists $couleurs_body{'alink'};
print "vlink = $couleurs_body{'vlink'}<br>\n" if exists $couleurs_body{'vlink'};
print "bgcolor = $couleurs_body{'bgcolor'}\n" if exists $couleurs_body{'bgcolor'};
print "</body></html>\n";
|
L'exemple définit un hash nommé %couleurs_body. Y sont définies les paires d'éléments pour les attributs habituels de l'élément body de HTML. À l'aide de la fonction delete la paire d'éléments complète pour bgcolor est ensuite effacée. Pour le contrôle, du code HTML est envoyé au navigateur et sort toutes les paires d'éléments. Les paires d'éléments ne sont toutefois sorties que si elles existent. Pour cela, la fonction exists est appliquée sur la paire d'éléments à sortir dans une requête if placée après. Les données sont sorties uniquement si le nom de la paire d'éléments est trouvé. Dans l'exemple, on évite par ce moyen que la ligne bgcolor = soit sortie avec une valeur vide.
|
|
Extrait certains éléments d'une liste, à savoir ceux qui satisfont à une condition déterminée, donc par exemple tous les chiffres impairs d'une liste de chiffres ou tous les fichiers à partir d'une certaine taille d'une liste de fichiers. Les éléments extraits sont sauvegardés dans une nouvelle liste distincte.
Attend comme paramètre:
1. la condition à laquelle doivent satisfaire les éléments à extraire de la liste. Il peut s'agir par exemple d'une expression régulière mais aussi d'une comparaison,
2. la liste à partir de laquelle les éléments doivent être extraits.
Renvoie une liste avec les éléments extraits qui remplissent la condition.
#!/usr/bin/perl -w
use strict;
use CGI::Carp qw(fatalsToBrowser);
opendir(DIR, "/usr/texte/articles");
my @Eintraege = readdir(DIR);
closedir(DIR);
chdir("/usr/texte/articles");
my @fichiers_HTML = grep(/\.htm/,@elements);
my @grands_fichiers = grep(-s > 50 * 1024, @elements);
print "Content-type: text/html\n\n";
print '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">', "\n";
print "<html><head><title>Test</title></head><body>\n";
print "<h2>Fichiers HTML du répertoire</h2>\n";
foreach(@fichiers_HTML) {
print "$_<br>\n";
}
print "<h2>Fichiers de plus de 50 kilo-octets dans le répertoire</h2>\n";
foreach(@grands_fichiers) {
print "$_<br>\n";
}
print "</body></html>\n";
|
Dans l'exemple un répertoire est lu. Les fichiers sont sauvegardés dans la liste @elements (pour la lecture de fichiers voir readdir). Ensuite et avec chdir il est passé dans le répertoire lu précédemment, parce que le deuxième des appels grep qui suivent exige que le répertoire lu soit le répertoire actuel.
Le premier des deux appels de grep recherche dans la liste lue @elements tous les éléments dans lesquels on trouve .htm. De cette façon, grep recherche tous les fichiers HTML de la liste. Les fichiers trouvés sont sauvegardés dans la liste renvoyée @fichiers_HTML.
Tandis que lors du premier appel de grep une expression régulière est employée, pour formuler la condition d'extraction, il s'agit lors du deuxième appel d'une comparaison, similaire à ce que l'on connaît par exemple des Instructions conditionnelles avec if, else et elsif. Dans l'exemple tous les éléments sont extraits pour lesquels la taille de fichier excède 50 Kilo-octets (50*1024 octets) . on se sert ici de l'un des opérateurs de test fichier pour fichiers et répertoires -s. Les fichiers trouvés sont sauvegardés dans la liste renvoyée @grands_fichiers.
L'exemple ci-dessus envoie ensuite du code HTML au navigateur et sort les deux listes trouvées pour les fichiers HTML et les fichiers dont la taille excède 50 kilo-octets.
|
|
Relie les éléments d'une liste en une chaîne de caractères. Dans la chaîne de caractères, les anciens éléments de la leste sont séparés les uns des autres par un signe déterminé ou une suite de signes déterminée.
Attend comme paramètre:
1. le signe ou la suite de signes qui doit servir à séparer les éléments de la liste,
2. la liste.
Renvoie une liste de caractères dans laquelle sont notés tous les éléments de la liste transmises séparés par le signe ou la suite de signes mentionnés pour la séparation.
#!/usr/bin/perl -w
use strict;
use CGI::Carp qw(fatalsToBrowser);
my @valeurs;
for(my $i=0; $i<16; $i++) {
$valeurs[$i] = 2 ** ($i+1);
}
my $chaine_valeurs = join(";",@valeurs);
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 "$chaine_valeurs\n";
print "</body></html>\n";
|
L'exemple génère une liste nommée @valeurs dans une boucle for. Y sont sauvegardés les résultats des opérations de 21 à 216 (à cet effet sert l' opérateur de calcul **). Cette liste est ensuite transmise à la fonction join. Un point virgule (;) est déterminé comme signe de séparation. Le résultat est sauvegardé dans la scalaire $chaine_valeurs, une simple chaîne de caractères. Pour le contrôle, du code HTML est envoyé au navigateur qui sort le résultat.
La fonction inverse pour créer une liste à partir d'une chaîne de caractères avec des signes de séparation et des valeurs est split.
|
|
Sauvegarde tous les noms de paire d'éléments d'un hash dans une liste.
Attend comme paramètre:
1. le hash.
Renvoie une liste des paires d'éléments.
#!/usr/bin/perl -w
use strict;
use CGI::Carp qw(fatalsToBrowser);
my @variables_environnement = keys(%ENV);
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 "<p>Les variables d'environnement suivantes sont définies:</p>\n";
print "<ul>\n";
foreach(@variables_environnement) {
print "<li>$_</li>\n";
}
print "</ul>\n";
print "</body></html>\n";
|
L'exemple recherche tous les noms du hash prédéfini %ENV dans la liste @variables_environnement. Pour le contrôle, du code HTML est envoyé au navigateur dans lequel sont listées toutes les variables d'environnement.
Dans l'exemple ne sont listés que les noms des variables d'environnement disponibles et pas leur valeur actuelle! La fonction pour ne rechercher que les valeurs d'un hash et pas leur nom est values.
|
|
Applique des commandes sur tous les éléments d'une liste. Pratiquement pour éviter une boucle for- ou foreach.
Attend comme paramètre:
1. une commande qui doit être appliquée à tous les éléments de la liste. Il peut s'agir d'une fonction mais aussi de toute une série d'instructions qui sont rassemblées dans un bloc,
2. la liste sur laquelle la commande doit être appliquée.
Renvoie la liste après traitement.
#!/usr/bin/perl -w
use strict;
use CGI::Carp qw(fatalsToBrowser);
my @fichiers = ("Index.htm","ACDC.html","acdc.jpg","oasis.htm","Oasis.jpg");
@fichiers = map(lc, @fichiers);
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";
foreach(@fichiers) {
print "$_<br>\n";
}
print "</body></html>\n";
|
Dans l'exemple est définie une liste avec des noms le fichiers. Les noms de fichiers contiennent en partie aussi des majuscules. Ensuite la fonction map est appliquée sur la liste. Ici la fonction lc est appliquée à tous les éléments de la liste et impose une écriture en minuscules de tous les signes. Pour le contrôle, l'exemple envoie du code HTML au navigateur et sort ainsi les éléments de la liste après traitement.
|
|
Retire d'une liste le dernier élément. La liste est raccourcie d'un élément.
Attend comme paramètre:
1. la liste.
Renvoie l'élément effacé.
#!/usr/bin/perl -w
use strict;
use CGI::Carp qw(fatalsToBrowser);
my $phrase = "Ne repousse pas à demain ce que tu peux faire le jour même";
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 "@signes<br>\n";
pop(@signes);
}
print "</body></html>\n";
|
L'exemple définit une phrase et en extrait les différents signes dans une liste (explications à ce sujet, voir la fonction substr). L'exemple envoie du code HTML au navigateur. Ici dans une boucle for, qui défilera aussi souvent qu'il y a de signes dans la phrase d'origine, la liste complète @signes est sortie à chaque fois. La liste est toutefois raccourcie du dernier élément à chaque boucle avec la fonction pop. Ainsi à chaque boucle un signe de moins est-il sorti.
|
|
Ajoute un ou plusieurs nouveaux éléments à la fin d'une liste.
Attend comme paramètre:
1. la liste à laquelle l'élément doit être ajouté,
2. à n. un ou plusieurs éléments à ajouter.
#!/usr/bin/perl -w
use strict;
use CGI::Carp qw(fatalsToBrowser);
my @villes = ("Wien","Madrid","Rome","Stockholm","Riga");
my @nouvelles_villes = ("Paris","Lisbonne","Sofia");
foreach(@nouvelles_villes) {
push(@villes,$_);
}
@villes = sort(@villes);
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";
foreach(@villes) {
print "$_<br>\n";
}
print "</body></html>\n";
|
Dans l'exemple deux listes sont définies: @villes et @nouvelles_villes. Dans une boucle foreach les éléments de la liste @nouvelles_villes sont ajoutés l'un après l'autre à la liste @villes. À l'aide de la fonction sort la nouvelle liste avec toutes les villes est triée en suite dans l'ordre "asciibétique" (d'après l'ordre des signes dans le jeu de caractères ASCII). L'exemple envoie du code HTML au navigateur dans lequel la nouvelle liste complète sera sortie pour le contrôle.
|
|
Inverse une liste de telle sorte que le premier élément est ensuite le dernier, le deuxième l'avant dernier etc...
Attend comme paramètre:
1. la liste souhaitée.
Renvoie la liste après traitement.
#!/usr/bin/perl -w
use strict;
use CGI::Carp qw(fatalsToBrowser);
my @nombres = (1..100);
@nombres = reverse(@nombres);
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";
foreach(@nombres) {
print "$_<br>\n";
}
print "</body></html>\n";
|
L'exemple définit une liste avec les nombres de 1 à 100. Ensuite la fonction reverse est appliquée à la liste, de telle façon qu'y soient sauvegardés les nombres de 100 à 1. Pour le contrôle du code HTML est envoyé au navigateur et sort la liste après traitement.
La fonction peut aussi être appliquée à des hashes. Exemple:
%Mailheader = reverse(%Mailheader);
Ici la clé et la valeur des éléments sont échangées l'une avec l'autre. Ce qui pose pourtant problème quand un hash a plusieurs valeurs identiques. Dans ce cas, seule une des valeurs du hash traité (qui sert maintenant de clé) est prise en compte.
|
|
Retire le premier élément d'une liste. le deuxième élément est ensuite le premier etc... La liste est raccourcie d'un élément.
Attend comme paramètre:
1. la liste devant être traitée.
Renvoie l'élément effacé.
#!/usr/bin/perl -w
use strict;
use CGI::Carp qw(fatalsToBrowser);
my @etats_d_esprit = ("peur, ","mélancolie, ","tristesse, ","rage, ","dissension, ","haine");
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 $max = @etats_d_esprit;
for(my $i = 0; $i < $max; $i++) {
print "<p>maintenant prédomine encore la @etats_d_esprit<br>\n";
shift(@etats_d_esprit);
}
print "<p>et maintenant règne la paix!</p>\n";
print "</body></html>\n";
|
L'exemple définit une liste avec des mauvais états d'esprit. Dans le code HTML qui est envoyé au navigateur est notée une boucle for. Elle sera parcourue aussi souvent que la liste d'origine compte d'éléments. Pour cela la longueur de la liste est sauvegardée dans la scalaire $max. À chaque passage de la boucle est sorti lesquels des mauvais états d'esprit prédominent encore. À chaque passage de la boucle, le premier des états d'esprit de la liste est effacé avec shift. Ce qui fait que la liste devient toujours plus petite et les états d'esprits moins nombreux. À la fin il n'y en a plus. Ensuite la boucle est également terminée et une phrase triomphale est encore sortie.
La fonction shift est aussi volontiers employée dans la pratique pour "traiter" des paramètres transmis dans des sous-programmes. Vous trouverez un exemple dans la partie expliquant comment appeler des sous-programmes avec des paramètres.
|
|
Trie les éléments d'une liste . Il y a ici deux possibilités. Soit vous triez la liste d'après l'algorithme de tri par défaut. Celui-ci trie par ordre alphabétique ou plus exactement "asciibétiquement" (d'après l'ordre des signes dans le jeu de caractères ASCII). Ou bien vous imposez votre propre algorithme de tri. Pour cela, vous définissez par exemple un sous-programme, qui accomplit l'algorithme correspondant. Ceci est important par exemple pour trier les éléments d'une liste numériquement.
Attend comme paramètre:
soit:
1. la liste à trier.
soit:
1. l'instruction ou le nom du sous programme avec l'algorithme de tri,
2. la liste à trier.
Renvoie la liste triée. Toutefois, il est important que la valeur renvoyée soit sauvegardée dans une autre liste que celle transmise en paramètre.
#!/usr/bin/perl -w
use strict;
use CGI::Carp qw(fatalsToBrowser);
my @amies = ("Ninon","Martine","Danièle","Christine","Isabelle","Sabine");
my @ordre = sort(@amies);
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(@ordre)
{
print "$_<br>\n";
}
print "</body></html>\n";
|
Cet exemple montre le tri simple standard. Il définit une liste de noms d'amies. Ensuite la liste est triée à l'aide de sort. La liste renvoyée est sauvegardée dans la nouvelle liste @ordre. Pour le contrôle, du code HTML est envoyé au navigateur et sort la liste triée.
#!/usr/bin/perl -w
use strict;
use CGI::Carp qw(fatalsToBrowser);
my @liste_meilleurs_resultats = (9834,9837,5989,4509,4329,6509,2837,8289,10845);
my @liste_triee = sort(tri_numerique @liste_meilleurs_resultats);
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(@liste_triee) {
print "$_<br>\n";
}
print "</body></html>\n";
sub tri_numerique {
if($a < $b)
{ return -1; }
elsif($a == $b)
{ return 0; }
else
{ return 1; }
}
|
Le deuxième exemple définit une liste nommée @liste_meilleurs_resultats. Ensuite la liste est triée à l'aide de sort. Étant donné qu'il s'agit de valeurs numériques une fonction est utilisée qui met à disposition l'algorithme de tri numérique. Car triée "asciibétiquement", la dernière valeur 10845 apparaîtrait au début de la liste triée dans l'ordre croissant ce qui ne doit pas être le cas étant donné qu'elle est la valeur la plus élevée qui doit apparaître en dernier. C'est pourquoi le nom du sous-programme est d'abord transmis à l'appel de sort et ensuite séparée par un espace (et non pas par une virgule!), la liste à trier. La liste renvoyée est sauvegardée dans l'exemple dans la nouvelle liste @liste_triee. Pour le contrôle du code HTML est envoyé au navigateur et sort la liste après traitement.
Le sous-programme tri_numerique noté dans l'exemple est écrit de façon générale et accomplit un simple tri numérique, tel qu'on l'attend de la fonction sort. Vous pouvez donc toujours utiliser ce sous-programme quand vous désirez trier des listes numériquement.
Pour obtenir un tri décroissant, vous pouvez par exemple , après l'application de sort, appliquer encore la fonction reverse à la liste.
|
|
retire un ou plusieurs éléments dans une liste et peut en outre insérer au même endroit un ou plusieurs éléments. C'est pourquoi splice est une espèce de fonction universelle pour la manipulation de listes qui permet entre autre tout ce que permettent de faire les différentes fonctions pop, push, shift et unshift et partant de là encore beaucoup plus.
Attend comme paramètre:
1. la liste devant être traitée,
2. numéro d'index de l'élément à partir duquel il faut effacer (pour celui-là le comptage commence à 0 pour le premier élément de la liste),
3. (facultatif) nombre d'éléments à effacer. Si rien n'est mentionné, tous les éléments jusqu'à la fin de la liste sont effacés! Pour n'effacer aucun élément donc pour en insérer seulement, il faut transmettre 0 à cet endroit.
4. à n. (facultatif) un à n éléments, qui doivent être insérés (à la place des éléments effacés).
Renvoie une liste avec les éléments effacés.
#!/usr/bin/perl -w
use strict;
use CGI::Carp qw(fatalsToBrowser);
my @enregistrement = ("Henri","Quatre","1 rue de la poule au pot","59100 Roubaix");
print "Content-type: text/html\n\n";
print '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">', "\n";
print "<html><head><title>Test</title></head><body>\n";
print "<h2>Nouvelle adresse électronique et nouveau site Web:</h2>\n";
splice(@enregistrement,2,0,"hdl\@ravaillac.net","http://www.ravaillac.net/hdl/");
my $Feld;
foreach $champ (@enregistrement) {
print "$champ<br>\n";
}
print "<h2>Nouvelle adresse:</h2>\n";
splice(@enregistrement,4,1);
splice(@enregistrement,-1,1,"Boite postale 1234, France");
foreach $champ (@enregistrement) {
print "$champ<br>\n";
}
print "</body></html>\n";
|
Dans l'exemple une liste nommée @enregistrement est définie et comprend plusieurs éléments. Du code HTML est envoyé au navigateur et sort la liste. La liste est ici cependant manipulée plusieurs fois avec splice. Dans un premier temps, les éléments pour l'adresse électronique et le site Web sont insérés dans l'enregistrement - à savoir derrière les deux premiers éléments, donc derrière le prénom et le nom. Pour ce faire le numéro d'index 2 est transmis comme deuxième paramètre pour le troisième élément. Aucun élément ne doit être effacé, les données doivent seulement être insérées. C'est pourquoi 0 est transmis comme troisième paramètre. Enfin, les deux nouveaux éléments pour l'adresse électronique et le site Web sont encore transmis. Pour le contrôle, la liste est ensuite d'abord sorti. Elle comprend à ce moment les éléments:
Henri,Quatre,hdl@ravaillac.net,http://www.ravaillac.net/hdl/,1 rue de la poule au pot,59100 Roubaix
La liste dans l'exemple continue néanmoins à être manipulée. D'abord l'élément avec le numéro d'index 4 est effacé (dans l'état actuel de @enregistrement la mention de rue. Le 1 transmis comme troisième paramètre fait en sorte que ce seul élément uniquement est effacé. @enregistrement comprend à ce moment les éléments:
Henri,Quatre,hdl@ravaillac.net,http://www.ravaillac.net/hdl/,59100 Roubaix
Tout de suite après dans l'exemple suit cependant un troisième appel de splice. Celui-ci remplace le dernier élément de la liste par un nouveau. Dans ce but est transmis comme deuxième paramètre -1. Étant donné que l'interpréteur Perl commence à compter à partir de la fin pour les nombres négatifs, -1 correspond donc au dernier numéro d'index, -2 à l'avant dernier etc.... Le troisième paramètre transmis est 1 de façon à ce que ce dernier élément soit effacé. Enfin un autre paramètre est encore transmis, à savoir l'élément de remplacement. Ainsi est créé l'effet que simplement une nouvelle valeur est affectée au dernier élément de la liste. En interne, il s'en passe pourtant davantage.
La liste a après le troisième appel de splice l'apparence suivante:
Elle comprend à ce moment les éléments:
Henri,Quatre,hdl@ravaillac.net,http://www.ravaillac.net/hdl/,Boite postale 1234, France.
Pour le contrôle, cet état est sorti encore une fois.
Le tableau suivant montre pour illustrer encore quelques exemples splice et leur correspondance par l'application d'autres fonctions pour les listes:
|
|
|
Retire une valeur d'un hash ou d'une liste. L'élément lui même est conservé. La valeur est en fin de compte fixée à la valeur undef.
Attend comme paramètre:
1.pour un hash le nom d'élément et pour une liste la mention du numéro d'ordre de l'élément. Peut en outre être également appliqué à de simples scalaires ou à des sous-programmes pour fixer leur valeur ou la valeur qu'ils renvoient sur undef.
Renvoie undef dans tous les cas.
#!/usr/bin/perl -w
use strict;
use CGI::Carp qw(fatalsToBrowser);
my @joueurs = ("Richard","Annie","Frédéric","Myriam");
my %points = ("Richard","350","Annie","400","Frédéric","150","Myriam","700");
undef($joueurs[2]);
undef($points{'Frédéric'});
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 "<p>Les joueurs suivants prennent part au jeu:</p>\n";
print "<ul>\n";
foreach(@joueurs) {
print "<li>$_</li>\n";
}
print "</ul>\n";
print "<p>Les points suivants sont à jour:</p>\n";
print "<ul>\n";
my @noms = keys(%points);
foreach(@noms) {
print "<li>$_: $points{$_} points</li>\n";
}
print "</ul>\n";
print "</body></html>\n";
|
L'exemple définit une liste nommée @joueurs et un hash nommé %points. Le joueur Frédéric, qui s'est retiré du jeu, est retiré des deux structures de données avec undef. L'élément de la liste pour Frédéric et la paire d'éléments correspondants dans le hash sont toutefois conservés. Dans la liste, la valeur donc le nom est retiré par undef, et dans le hash, le nom Frédéric est conservé, seule sa valeur attribuée 100 est retirée. "Retiré" signifie dans les deux cas que la valeur est fixée sur undef undef. Pour le contrôle, du code HTML est envoyé au navigateur dans l'exemple et sort toutes les données. Les éléments retirés sont sortis parce qu'ils existent encore, sans valeur visible toutefois. Au lieu de cela, il y a lors de l'accès à ces éléments un message d'erreur. La valeur undef signifie que la scalaire correspondante ou l'élément correspondant n'a pas (encore) de valeur. Il est "indéfini". La requête peut cependant porter sur undef. Exemple:
unless (defined $points{'Frédéric'}) { print "Frédéric a quitté la partie"; }.
Pour effacer complètement une paire d'éléments dans un hash, il y a la fonction delete. Pour effacer complètement un élément d'une liste, vous disposez des fonctions pop, shift et splice.
|
|
Ajouter un ou plusieurs nouveaux éléments au début d'une liste. La liste se rallonge d'autant.
Attend comme paramètre:
1. la liste désirée,
2. à n. le ou les éléments à insérer au début de la liste.
#!/usr/bin/perl -w
use strict;
use CGI::Carp qw(fatalsToBrowser);
my @liens=("<a href=\"http://actuel.fr.selfhtml.org/\">actuel.fr.selfhtml.org</a><br>\n",
"<a href=\"http://www.ac-toulouse.fr/\">toulouse.fr</a><br>\n",
"<a href=\"http://www.willy-online.de/\">willy-online.de</a><br>\n");
print "Content-type: text/html\n\n";
print '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">', "\n";
print "<html><head><title>Test</title></head><body>\n";
unshift(@liens,"<a href=\"http://www.gtands-gars.fr/\">grands-gars.fr</a><br>\n");
print "@liens";
print "</body></html>\n";
|
L'exemple définit une liste avec trois liens WWW, notés tout prêts comme liens HTML. Du code HTML est envoyé au navigateur. Avant que la liste avec les liens ne soit sortie, un nouvel élément est ajouté au début de la liste avec unshift. Ensuite toute la liste est alors sortie avec maintenant quatre liens, le lien ajouté figurant en premier.
|
|
Sauvegarde toutes les valeurs des paires d'éléments d'un hash dans une liste.
Attend comme paramètre:
1. le hash.
Renvoie une liste avec les valeurs des paires d'éléments.
#!/usr/bin/perl -w
use strict;
use CGI::Carp qw(fatalsToBrowser);
my @valeurs_environnement = values(%ENV);
my @variables_environnement = keys(%ENV);
my @environnement;
for(my $i=0; $i < @valeurs_environnement; $i++) {
$environnement[$i] = $variables_environnement[$i]." = ".$valeurs_environnement[$i];
}
@environnement = sort(@environnement);
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 "<p>Les valeurs d'environnement suivantes sont définies:</p>\n";
print "<ul>\n";
foreach(@environnement) {
print "<li>$_</li>\n";
}
print "</ul>\n";
print "</body></html>\n";
|
L'exemple recherche avec values toutes les valeurs du hash prédéfini %ENV dans la liste @valeurs_environnement. à l'aide de la fonction keys une liste correspondante @variables_environnement est créée pour les noms d'éléments du hash. Ensuite est créée une nouvelle liste @environnement. Dans cette liste sont fusionnées les deux listes pour les noms et les valeurs dans une boucle for. Chaque élément de la liste @environnement comporte le nom respectif d'une variable d'environnement, d'un signe égal et de la valeur qui s'y rapporte (voir aussi: Opérateur pour concaténer des chaînes de caractères). Cette nouvelle liste est triée à l'aide de la fonction sort. Ensuite du code HTML est envoyé au navigateur et sort la liste triée.
|
| |
 |
Fonctions pour les calculs
|
 |
Fonctions pour les chaînes de caractères
|
| SELFHTML/Aides à la navigation CGI/Perl Fonctions Perl |
© 2001 Stefan Münz / © 2003 Traduction 
Serge François, 13405@free.fr selfhtml@fr.selfhtml.org