SELFHTML: CGI/Perl / Éléments de langage Perl / Variables prédéfinies en Perl

	Variables prédéfinies en Perl
	Généralités sur les variables prédéfinies Scalaires prédéfinies Listes et hashes prédéfinis

Généralités sur les variables prédéfinies

Perl dispose d'une quantité de variables spéciales prédéfinies. Vous pouvez lire le contenu de ces variables pour rechercher des informations sur la configuration Perl actuelle ou pour rechercher la configuration système de l'ordinateur sur lequel tournent le script et l'interpréteur Perl. Quelques unes de ces variables sont des variables utilitaires qui facilitent la programmation. Il y a ainsi par exemple une variable qui tient à disposition dans une boucle la valeur respectivement actuelle ou une variable qui sauvegarde le paramètre transmis.

Beaucoup de ces variables prédéfinies ont optiquement un air revêche et c'est une des raisons pour lesquelles Perl passe quelquefois pour un langage incompréhensible de pirate informatique. Car pour celui qui ne s'y connaît pas en Perl, des noms de variables tels que $_, $/, $" ou bien $% frisent le charabia. À côté de cette notation abrégé classique, il y a pour cette raison également une variante en "texte clair" de ces variables. Pour cela, il faut cependant incorporer un module nommé English, qui a pourtant l'inconvénient de faire chuter la vitesse d'exécution du script et d'augmenter les besoins en ressources comme c'est le cas pour tous les autres modules. À cela s'oppose l'avantage que votre programme est plus lisible.

L'exemple suivant montre quelques unes des variables prédéfinies en action:

Exemple d'un script CGI complet:

#!/usr/bin/perl -w

use strict;
use CGI::Carp qw(fatalsToBrowser);
use English;

print "Content-type: text/plain\n\n";
print "===Scalaires prédéfinies====================================\n\n";
print "Numéro de processus du processus en cours d'exécution: $$ ou $PID\n";
print "Fichier exécuté pour ce processus:  $0 ou $PROGRAM_NAME \n";
print "Interpréteur exécuté lors de ce processus:  $^X ou $EXECUTABLE_NAME \n";
print "Numéro de version de l'interpréteur Perl:  $] oder $PERL_VERSION \n";
print "Heure de lancement du processus:  $^T ou $BASETIME \n";
print "Système d'exploitation:  $^O oder $OSNAME \n";
print "\n\n===Listes prédéfinies=====================================\n\n";
print "Arguments transmis:\n";
my $i = 0;
foreach (@ARGV) {
  print ++$i,". Argument: $_\n";
}
$i = 0;
print "\nChemin de recherche pour modules Perl:\n";
foreach (@INC) {
  print ++$i,". Chemin: $_\n";
}
print "\n\n===Hash prédéfini======================================\n\n";
foreach (keys %ENV) {
  printf " %20s:  $ENV{$_} \n",$_;
}

Explication:

L'exemple envoie du texte au navigateur appelant avec le type Mime text/plain. Ce faisant, les valeurs de différentes valeurs prédéfinies sont sorties. Quelques unes sont sorties deux fois pour contrôle, à savoir une fois dans la forme abrégée classique et une fois dans la forme en texte clair, qui n'est toutefois possible que parce que, avec use English; le module standard correspondant est incorporé. Ainsi par exemple $$ et $PID ont la même valeur.

Les différents éléments de tableaux et hashes prédéfinis comme @ARGV, @INC et %ENV sont sortis après avoir été formatés proprement dans le script chacun à l'aide d'une boucle foreach. Là est également utilisée la scalaire prédéfinie $_, qui est bien la variable prédéfinie utilisée le plus souvent dans la pratique.

Le tableau @ARGV est d'ailleurs vide, aussi longtemps que vous appelez le script comme script CGI sans paramètre. Pour tester, vous pouvez mentionner des paramètres dans la ligne d'adresse pour l'appel. Supposons que le script ait comme adresse http://127.0.0.1/cgi-bin/test.pl, alors essayez un appel tel que http://127.0.0.1/cgi-bin/test.pl?Hello&monde.

Scalaires prédéfinies

Les tableaux décrivent des scalaires prédéfinies. Il n'y a des exemples que là où ils ne nécessitent pas un contexte plus important. Quelques unes des scalaires sont spécifiques au système d'exploitation ou plutôt ont un sens exclusivement dans des environnements Unix.

Pour utiliser les formes longues des variables, vous devez incorporer le module standard correspondant use English; dans votre script.

Scalaires prédéfinies pour le déroulement du programme et les expressions régulières

Forme abrégée	Forme longue	Signification	Petit exemple
`$_`	`$ARG`	contient dans des boucles (par exemple pour la recherche dans une liste avec foreach ) quand aucune autre variable n'a été mentionnée la valeur actuelle respective ou l'argument actuel respectif. Est accepté par quelques fonctions Perl comme argument, c'est à dire qu'aucune valeur explicite ne doit être transmise aux fonctions quand `$_` est considéré comme argument. Contient lors d'opérations avec des expressions régulières la valeur respectivement actuelle.	@nombres = (1..10); foreach(@nombres) { print $_, "\n"; }
`$1`, `$2` etc...		Contient, lors d'opérations avec des expressions régulières, la valeur d'une expression partielle repérée entre parenthèses. Lecture seule, modification impossible.	if(/from: (.*)/) { $expediteur = $1; }
`$&`	`$MATCH`	Contient après l'utilisation d'une expression régulière la valeur correspondant au modèle de recherche. Lecture seule, modification impossible. L'emploi de cette variable ralentit tout le programme, c'est pourquoi son emploi n'est pas recommandé par les professionnels.	$_ = "homme et femme"; /et/; print "$&\n";
$`	`$PREMATCH`	Contient la partie de l'expression complète avant la dernière valeur correspondant au modèle de recherche. Lecture seule, modification impossible. Le signe ` est l'accent grave. Sur beaucoup de claviers appuyez les touche majuscule et touche d'accent suivies d'un espace. L'emploi de cette variable ralentit tout le programme, c'est pourquoi son emploi n'est pas recommandé par les professionnels.	$_ = "homme et femme"; / et/; print "$`\n";
`$'`	`$POSTMATCH`	Contient la partie de l'expression complète après la dernière valeur correspondant au modèle de recherche. Lecture seule, modification impossible. Le signe `'` est l'apostrophe. L'emploi de cette variable ralentit tout le programme, c'est pourquoi son emploi n'est pas recommandé par les professionnels.	$_ = "homme et femme"; /et /; print "$'\n";
`$+`	`$LAST_PAREN_MATCH`	Contient après l'application d'une expression régulière avec parenthèses le contenu de la dernière parenthèse. Lecture seule, modification impossible.	$_ = "homme et femme"; /([a-zA-Z]) et ([a-zA-Z])/; print "$+\n";
`$.`	`$NR $INPUT_LINE_NR`	contient le numéro de ligne actuelle du dernier fichier consulté. Dans l'exemple ci-contre toutes les lignes d'un fichier texte sont lues et sorties. À la fin, `$.` peut renseigner sur le nombre de lignes ayant été lues.	open(FICHIER, "<readme.txt"); while(<FICHIER>) { print $_; } print $., " lignes lues"; close(FICHIER);
`$/`	`$RS INPUT_RECORD_SEPARATOR`	contient le séparateur de saisie fixé. peut être modifié - même plusieurs signes sont permis. L'exemple ci-contre fait en sorte que la saisie du périphérique de saisie standard ne sera close que si l'utilisateur entre la chaîne de caractères `FIN` et presse la touche `Entrée`. La valeur par défaut est le signe de passage à la ligne `\n`	$/ = "FIN"; $ton_nom = <STDIN>; print $ton_nom;
`$\`	`$ORS OUTPUT_RECORD_SEPARATOR`	Permet l'affectation d'une chaîne de caractères qui est insérée à chaque sortie avec print .	$\ = ";"; print "une valeur";
`$,`	`$OFS OUTPUT_FIELD_SEPARATOR`	Permet l'affectation d'une chaîne de caractères qui est ajoutée automatiquement à chaque valeur distincte sortie avec print sous forme de plusieurs valeurs distinctes séparées par des virgules.	$, = ","; print "valeur","encore une";
`$"`	`$LIST_SEPARATOR`	Permet l'affectation d'une chaîne de caractères qui est ajoutée automatiquement à chaque valeur distincte sauf la dernière, quand une liste ou un tableau dans une chaîne de caractères est sortie interpolée avec print.	$" = "-"; @Liste = (1,2,3,4); print "@Liste";
`$\|`	`$OUTPUT_AUTOFLUSH`	Quand cette variable est fixée sur une valeur différente de `0`, Les sorties avec `print` ne sont pas mises en mémoire tampon, mais ont lieu à l'instant où l'instruction `print` est interprétée. Normalement, les sorties en Perl transitent en mémoire tampon pour être ensuite sorties sous forme de blocs.	$\| = 1;
`$%`	`$FORMAT_PAGE_NUMBER`	Voir la fonction format.
`$=`	`$FORMAT_LINES_PER_PAGE`	Voir la fonction format.
`$-`	`$FORMAT_LINES_LEFT`	Voir la fonction format.
`$~`	`$FORMAT_NAME`	Voir la fonction format.
`$^`	`$FORMAT_TOP_NAME`	Voir la fonction format.
`$:`	`$FORMAT_LINE_ BREAK_CHARACTERS`	Voir la fonction format.
`$^L`	`$FORMAT_FORMFEED`	Voir la fonction format.
`$^A`	`$ACCUMULATOR`	Voir la fonction format.

Scalaires prédéfinies pour des informations sur l'environnement

Forme abrégée	Forme longue	Signification	Petit exemple
`$?`	`$CHILD_ERROR`	Contient l'état qui, en dernier par un appel système, a été généré par un processus enfant d'un filtre fermé ou par des Backticks.	system($command) == 0 or die "Erreur système: $?"
`$!`	`$ERRNO $OS_ERROR`	contient un message d'erreur actuel ou un code d'erreur dans le contexte du programme actuel dans la mesure ou une erreur est survenue. L'instruction ci-contre essaie d'ouvrir un fichier et donne en cas d'erreur le message d'erreur Perl prédéfini quand le fichier ne peut pas être ouvert et termine le programme.	open(FICHIER, "<pas_la.txt") or die "Erreur à l'ouverture: $!";
`$@`	`$EVAL_ERROR`	Contient une valeur différente de `null`, dans la mesure où une erreur est survenue lors de l'application de eval. Si aucune erreur n'est survenue, elle ne contient rien.	eval { system("dir"); }; if($@) { print "dir est impossible\n"; }
`$$`	`$PID $PROCESS_ID`	Contient l'ID de processus du processus actuel, dans lequel tourne le script, tel qu'il a été affecté par le système d'exploitation.	print $$;
`$<`	`$UID REAL_USER_ID`	Contient l'ID utilisateur réel de l'utilisateur ayant lancé l'exécution du processus actuel (dans la mesure où le système d'exploitation où l'interpréteur Perl a été traduit le soutient).	print $<;
`$>`	`$EID EFFECTIVE_USER_ID`	Contient l'ID utilisateur effectif de l'utilisateur ayant lancé l'exécution du processus actuel (dans la mesure où le système d'exploitation où l'interpréteur Perl a été traduit le soutient).	print $>;
`$(`	`$GID REAL_GROUP_ID`	Contient l'ID groupe réel de l'utilisateur ayant lancé l'exécution du processus actuel (dans la mesure où le système d'exploitation où l'interpréteur Perl a été traduit le soutient).	print $(;
`$)`	`$EGID EFFECTIVE_GROUP_ID`	Contient l'ID groupe effectif de l'utilisateur ayant lancé l'exécution du processus actuel (dans la mesure où le système d'exploitation où l'interpréteur Perl a été traduit le soutient).	print $);
`$0`	`$PROGRAM_NAME`	Contient le nom du script qui tourne.	print $0;
`$]`	`$PERL_VERSION`	Contient le numéro de version exact de l'interpréteur Perl qui exécute le script.	print $];
`$^D`	`$DEBUGGING`	Contient la valeur actuelle des drapeaux de débogage (Résultat de l'option d'appel Perl `-D`).	print $^D;
`$^F`	`$SYSTEM_FD_MAX`	Contient la valeur du descripteur de fichiers ouvert le plus élevé - normalement la valeur `2`.	print $^F;
`$^H`		Contient le nombre de vérifications syntaxiques exécutées par Perl avec la mention `use strict;` et autres mentions sur une vérification syntaxique sévère.	print $^H;
`$^I`	`$INPLACE_EDIT`	est `defined` ou `undef`, selon que le drapeau Inplace-Edit est fixé ou non.	print $^I;
`$^M`		peut enregistrer des données au cas où Perl ne peut pas poursuivre l'exécution du script à cause d'une mémoire de travail insuffisante. L'instruction ci-contre réserve 64 kilo-octets de mémoire de travail pour le cas où Perl, lors de l'exécution du script, ne peut plus réserver de nouvelle place mémoire pour les données nécessaires. Cette propriété doit être activée explicitement lors de la traduction de l'interpréteur Perl pour pouvoir être utilisée.	$^M = 'a' x (1<<16);
`$^O`	`$OSNAME`	Nom du système d'exploitation.	print $^O;
`$^P`	`$PERLDB`	Contient l'état actuel de débogage.	print $^P;
`$^S`		Contient l'état actuel de l'interpréteur Perl. Quand un appel de eval n'est pas terminé, cette variable a pour valeur `undef`.	eval { system("rm_all_old"); }; print $^S;
`$^T`	`$BASETIME`	Contient la date et l'heure auxquelles le script a été lancé. La valeur s'exprime en secondes écoulées entre le 1/1/1970, 0.00 heures et le moment où le script a été lancé.	print "Start: $^T, "; sleep(3); my $maintenant = time; print "et maintenant: $maintenant";
`$^W`	`$WARNING`	Est vrai (1), quand l'option d'appel Perl `-w` est fixée, et faux (0), quand elle ne l'est pas.	print "Attention!" if($^W);
`$^X`	`$EXECUTABLE_NAME`	Contient le nom du fichier exécutable de l'interpréteur Perl qui exécute le script.	print $^X;

Listes et hashes prédéfinis

Forme abrégée	Signification	Petit exemple
`@_`	Contient les paramètres transmis lors de l'appel d'un sous-programme. À l'intérieur du sous-programme, les paramètres transmis peuvent être adressés avec `$_[0]` (= premier paramètre), `$_[1]` (= deuxième paramètre) etc.... @_ est l'argument standard dans des sous-programmes pour l'appel de la fonction shift. Vous pouvez donc affecter à la variable `$premier` le premier paramètre transmis par exemple avec `my $premier = shift;` et le retirer en même temps de la liste des paramètres.	&Dis("Hello monde"); sub Dis { print $_[0]; }
`@ARGV`	Contient les paramètres transmis lors de l'appel d'un script Perl. Si par exemple `perl test.pl mon_texte.txt` a été entré, `mon_texte.txt` est le premier paramètre pour le script Perl. Le script peut évaluer des paramètres en entrée pour le déroulement du programme. Dans l'exemple ci-contre, le premier paramètre transmis `$ARGV[0]` est interprété comme nom de fichier. Le script essaie d'ouvrir ce fichier. `@ARGV` est dans le contexte global du fichier l'argument standard pour l'appel de la fonction `shift`.	if (open(FICHIER, "< $ARGV[0]")) { print "$ARGV[0] ouvert!"; close(FICHIER); }
`@INC`	Contient les chemins dans lesquels Perl doit rechercher les modules incorporés.	print @INC;
`@ISA`	Contient une liste de classes de base dont une classe doit hériter des méthodes pour le programmation orientée objet.	use vars qw(@ISA); @ISA = qw(Base); print @ISA;
`@EXPORT`	peut être mis en œuvre pour les modules. Peut enregistrer les noms du module qui sont exportés absolument dans l'espace de nommage du script qui incorpore ce module. Voir Utilisation étendue de use.	@EXPORT = qw(%CHAMPS_FORMULAIRE);
`@EXPORT_OK`	peut être mis en œuvre pour les modules. Peut enregistrer les noms du module que le script qui l'incorpore peut adopter dans son propre espace de nommage mais ne le doit pas. Voir Utilisation étendue de use.	@EXPORT_OK = qw($horodateur @donnees_Log);
`%ENV`	Contient les variables d'environnement qui, à l'appel du script, ont été transmises par le système appelant. Pour les scripts CGI les variables d'environnement sont fixées par le serveur Web et sont disponibles comme variables d'environnement CGI.	$, = "\n"; print keys(%SIG);
`%SIG`	Contient les gestionnaires de signal disponibles qui permettent à un script Perl de réagir à des signaux définis qu'il reçoit d'autres processus qui tournent.	$, = "\n"; print keys(%SIG);


	Chaînes de caractères (Strings)
	Références ou pointeurs (Variables)

SELFHTML/Aides à la navigation

CGI/Perl

Éléments de langage Perl