perlvar - En ligne dans le cloud

PROGRAMME:

Nom

perlvar - Variables prédéfinies Perl

DESCRIPTION

L'exposition Syntaxe of Variable Des noms
Les noms de variables en Perl peuvent avoir plusieurs formats. Habituellement, ils doivent commencer par une lettre
ou un soulignement, auquel cas ils peuvent être arbitrairement longs (jusqu'à une limite interne de 251
caractères) et peut contenir des lettres, des chiffres, des traits de soulignement ou la séquence spéciale "::" ou
"'". Dans ce cas, la partie précédant le dernier "::" ou "'" est considérée comme un paquet
qualificatif; voir perlmod.

Les noms de variables Perl peuvent également être une séquence de chiffres ou un seul signe de ponctuation ou un contrôle.
caractère (avec la forme de caractère de contrôle littéral obsolète). Ces noms sont tous
réservé à des usages spéciaux par Perl ; par exemple, les noms composés uniquement de chiffres sont utilisés pour contenir des données
capturé par les références arrière après une correspondance d’expression régulière. Perl a une syntaxe spéciale
pour les noms de caractères de contrôle unique : il comprend "^X" (caret "X") comme signifiant le
contrôle-caractère "X". Par exemple, la notation $^W (caret de signe dollar "W") est le
variable scalaire dont le nom est le contrôle à un seul caractère "W". C'est mieux que
en tapant un contrôle littéral-"W" dans votre programme.

Depuis Perl v5.6.0, les noms de variables Perl peuvent être des chaînes alphanumériques commençant par un caret.
(ou un caractère de contrôle, mais cette forme est obsolète). Ces variables doivent être écrites en
la forme "${^Foo}" ; les bretelles ne sont pas facultatives. "${^Foo}" désigne la variable scalaire
dont le nom est un contrôle "F" suivi de deux "o". Ces variables sont réservées à
utilisations spéciales futures par Perl, à l'exception de celles qui commencent par "^_" (contrôle-trait de soulignement
ou un trait de soulignement). Aucun nom de caractère de contrôle commençant par "^_" n'obtiendra un
signification particulière dans toute version future de Perl ; ces noms peuvent donc être utilisés en toute sécurité dans
programmes. $^_ lui-même, cependant, is réservé.

Les identifiants Perl qui commencent par des chiffres, des caractères de contrôle ou des caractères de ponctuation sont
exemptés des effets de la déclaration « colis » et sont toujours contraints d'être en
paquet « principal » ; ils sont également exemptés des erreurs « vars » strictes. Quelques autres noms sont
également exonéré de ces manières :

ENV STDIN
INC STDOUT
ARGV STDERR
ARGVOUT
SIG

En particulier, les variables spéciales "${^_XYZ}" sont toujours considérées comme étant dans le package "main",
indépendamment des déclarations de « package » actuellement dans la portée.

SPÉCIALITÉS VARIABLES

Les noms suivants ont une signification particulière pour Perl. La plupart des noms de ponctuation ont des
mnémoniques ou analogues dans les coquilles. Néanmoins, si vous souhaitez utiliser une variable longue
noms, il vous suffit de dire :

utiliser l'anglais;

en haut de votre programme. Cela alias tous les noms courts vers les noms longs dans le
forfait actuel. Certains portent même des noms moyens, généralement empruntés à awk. Pour en savoir plus
Pour plus d'informations, veuillez consulter l'anglais.

Avant de continuer, notez l'ordre de tri des variables. En général, nous énumérons d'abord les
variables dans un ordre presque lexigraphique insensible à la casse (en ignorant le "{" ou "^"
mots précédents, comme dans "${^UNICODE}" ou $^T), bien que $_ et @_ se déplacent vers le haut du
pile. Pour les variables avec le même identifiant, nous les listons par ordre scalaire, tableau, hachage,
et à mots nus.

Général Variables
$ ARG
$_ L'espace de saisie et de recherche de modèles par défaut. Les paires suivantes sont
équivalent:

while (<>) {...} # équivalent uniquement dans while !
tandis que (défini($_ = <>)) {...}

/^Sujet :/
$_ =~ /^Sujet :/

tr/az/AZ/
$_ =~ tr/az/AZ/

chomp
bouffer($_)

Voici les endroits où Perl assumera $_ même si vous ne l'utilisez pas :

· Les fonctions suivantes utilisent $_ comme argument par défaut :

abdos, alarme, chomp, chop, chr, chroot, cos, défini, eval, evalbytes, exp, fc,
glob, hex, int, lc, lcfirst, longueur, log, lstat, mkdir, oct, ord, pos, imprimer,
printf, quotemeta, readlink, readpipe, ref, require, reverse (dans un contexte scalaire
uniquement), rmdir, disons, sin, split (pour son deuxième argument), sqrt, stat, study, uc,
ucfirst, dissocier, décompresser.

· Tous les tests de fichiers ("-f", "-d") à l'exception de "-t", qui est par défaut STDIN. Voir "-X"
en mode perlfunc

· Les opérations de correspondance de motifs "m//", "s///" et "tr///" (alias "y///") lorsque
utilisé sans opérateur "=~".

· La variable itératrice par défaut dans une boucle "foreach" si aucune autre variable n'est
fourni.

· La variable itératrice implicite dans les fonctions "grep()" et "map()".

· La variable implicite de "given()".

· L'endroit par défaut pour mettre la valeur suivante ou l'enregistrement d'entrée lorsqu'un "",
Le résultat de l'opération "readline", "readdir" ou "each" est testé par lui-même en tant que
seul critère d'un test "tandis". En dehors d'un test "while", cela ne fonctionnera pas
arriver.

$_ est par défaut une variable globale. Cependant, depuis Perl v5.10.0, vous pouvez utiliser un
version lexicale de $_ en le déclarant dans un fichier ou dans un bloc avec "my".
De plus, déclarer « notre $_ » restaure le $_ global dans la portée actuelle. Cependant
cela semblait être une bonne idée au moment où elle a été introduite, lexical $_ en fait
pose plus de problèmes qu’elle n’en résout. Si vous appelez une fonction qui s'attend à être
transmis des informations via $_, cela peut fonctionner ou non, selon la façon dont la fonction
est écrit, il n’existe pas de moyen simple de résoudre ce problème. Évitez simplement le $_ lexical,
à moins que vous ne vous sentiez particulièrement masochiste. Pour cette raison le lexical $_ est
encore expérimental et produira un avertissement à moins que les avertissements n'aient été désactivés.
Comme pour d’autres fonctionnalités expérimentales, le comportement du $_ lexical est soumis à
modification sans préavis, y compris la transformation en une erreur fatale.

Mnémonique : le soulignement est compris dans certaines opérations.

@ARG
@_ Dans un sous-programme, le tableau @_ contient les paramètres transmis à ce sous-programme
sous-programme. Dans un sous-programme, @_ est le tableau par défaut pour les opérateurs de tableau
"pop" et "shift".

Voir perlsub.

$LIST_SEPARATOR
$" Lorsqu'un tableau ou une tranche de tableau est interpolé dans une chaîne entre guillemets doubles ou un
contexte similaire tel que "/.../", ses éléments sont séparés par cette valeur.
La valeur par défaut est un espace. Par exemple, ceci :

print "Le tableau est : @array\n";

équivaut à ceci :

print "Le tableau est : " . join($", @array) . "\n";

Mnémonique : fonctionne dans un contexte entre guillemets.

$PROCESS_ID
$PID
$$ Le numéro de processus du Perl exécutant ce script. Même si tu Vous pouvez régler ça
variable, cela est généralement déconseillé, bien que cela puisse être inestimable pour
à des fins de tests. Il sera réinitialisé automatiquement lors des appels "fork()".

Remarque pour les utilisateurs de Linux et Debian GNU/kFreeBSD : avant Perl v5.16.0, Perl
émuler la sémantique POSIX sur les systèmes Linux à l'aide de LinuxThreads, une version partielle
implémentation de POSIX Threads qui a depuis été remplacé par Native POSIX
Bibliothèque de fils de discussion (NPTL).

LinuxThreads est désormais obsolète sous Linux, et la mise en cache de "getpid()" comme celle-ci rend
intégrer Perl inutilement complexe (puisque vous devrez mettre à jour manuellement le
valeur de $$), donc maintenant $$ et "getppid()" renverront toujours les mêmes valeurs que le
bibliothèque C sous-jacente.

Les systèmes Debian GNU/kFreeBSD utilisaient également LinuxThreads jusqu'à la version 6.0 incluse.
version, mais ensuite déplacé vers la sémantique des threads FreeBSD, qui est de type POSIX.

Pour voir si votre système est affecté par cette divergence, vérifiez si "getconf
GNU_LIBPTHREAD_VERSION | grep -q NPTL" renvoie une valeur fausse. Threads NTPL
préserver la sémantique POSIX.

Mnémonique : identique aux obus.

$PROGRAM_NAME
$0 Contient le nom du programme en cours d'exécution.

Sur certains systèmes d'exploitation (mais pas tous), l'attribution de $0 modifie la zone d'argument.
que le programme "ps" voit. Sur certaines plateformes, vous devrez peut-être utiliser des "ps" spéciaux
options ou un "ps" différent pour voir les changements. Modifier le $0 est plus utile
comme moyen d'indiquer l'état actuel du programme plutôt que de masquer le programme
tu cours.

Notez qu'il existe des limitations spécifiques à la plate-forme concernant la longueur maximale de 0 $. Dans
dans le cas le plus extrême, il peut être limité à l'espace occupé par le $0 d'origine.

Sur certaines plates-formes, il peut y avoir une quantité arbitraire de remplissage, par exemple de l'espace
caractères, après le nom modifié comme indiqué par "ps". Sur certaines plateformes, ceci
le remplissage peut s'étendre jusqu'à la longueur d'origine de la zone d'argument, non
peu importe ce que vous faites (c'est le cas par exemple avec Linux 2.2).

Remarque pour les utilisateurs de BSD : définir $0 ne supprime pas complètement "perl" du ps(1)
sortir. Par exemple, définir $0 sur "foobar" peut entraîner "perl: foobar (perl)"
(L'affichage du préfixe "perl: " et du suffixe " (perl)" dépend de
votre variante et version exactes de BSD). Ceci est une fonctionnalité du système d'exploitation, Perl
ne peut pas l'aider.

Dans les scripts multithread, Perl coordonne les threads afin que n'importe quel thread puisse
modifier sa copie du $0 et le changement devient visible à ps(1) (en supposant que
le système d'exploitation joue le jeu). Notez que la vue de $0 qu'ont les autres threads
ne changera pas puisqu'ils en ont leurs propres copies.

Si le programme a été donné à Perl via les commutateurs "-e" ou "-E", $0 sera
contenir la chaîne "-e".

Sous Linux, à partir de Perl v5.14.0, le nom du processus hérité sera défini avec prctl(2), dans
en plus de modifier le nom POSIX via "argv[0]" comme Perl le fait depuis la version
4.000. Désormais, les utilitaires système qui lisent le nom du processus hérité, tel que ps, top et
killall reconnaîtra le nom que vous avez défini lors de l'attribution à $0. La chaîne que tu
l'approvisionnement sera coupé à 16 octets, c'est une limitation imposée par Linux.

Mnémonique : identique à sh et ksh.

$REAL_GROUP_ID
$GID
$( Le véritable guide de ce processus. Si vous êtes sur une machine qui prend en charge l'adhésion à
plusieurs groupes simultanément, donne une liste des groupes dans lesquels vous appartenez, séparés par des espaces.
Le premier numéro est celui renvoyé par "getgid()", et les suivants par
"getgroups()", dont l'un peut être identique au premier nombre.

Cependant, une valeur attribuée à $( doit être un nombre unique utilisé pour définir le véritable gid.
Donc la valeur donnée par $( devrait pas être réaffecté à $( sans être forcé
numérique, par exemple en ajoutant zéro. Notez que ceci est différent du gid effectif
($)) qui prend une liste.

Vous pouvez modifier à la fois le gid réel et le gid effectif en utilisant
"POSIX :: setgid ()". Les modifications apportées à $( nécessitent une vérification à $! pour détecter tout éventuel
erreurs après une tentative de modification.

Mnémonique : les parenthèses sont utilisées pour groupe des choses. Le vrai truc, c'est le groupe que vous
à gauche, si vous exécutez setgid.

$EFFECTIVE_GROUP_ID
$EGID
$) Le guide efficace de ce processus. Si vous êtes sur une machine prenant en charge
l'appartenance à plusieurs groupes simultanément, donne une liste de
groupes dans lesquels vous appartenez. Le premier nombre est celui renvoyé par "getegid()", et le
les suivants par "getgroups()", dont l'un peut être le même que le premier
.

De même, une valeur attribuée à $) doit également être une liste de nombres séparés par des espaces.
Le premier nombre définit le gid effectif et le reste (le cas échéant) est transmis à
"setgroups()". Pour obtenir l'effet d'une liste vide pour "setgroups()", répétez simplement
le nouveau guide effectif ; c'est-à-dire pour forcer un gid effectif de 5 et un gid efficace
liste "setgroups()" vide, dites " $) = "5 5" ".

Vous pouvez modifier à la fois le gid effectif et le gid réel en utilisant
"POSIX::setgid()" (utilisez un seul argument numérique). Les modifications apportées à $) nécessitent un
chèque à $! pour détecter d'éventuelles erreurs après une tentative de modification.

$<, $>, $( et $) ne peuvent être définis que sur les machines prenant en charge le
set[re][ug]id() routine. $( et $) ne peuvent être échangés que sur les machines prenant en charge
"setregid()".

Mnémonique : les parenthèses sont utilisées pour groupe des choses. Le groupe efficace est le groupe
bien pour vous, si vous utilisez setgid.

$REAL_USER_ID
$UID
$< Le véritable ID de ce processus. Vous pouvez modifier à la fois le fluide réel et le fluide effectif.
uid en même temps en utilisant "POSIX::setuid()". Puisque les modifications apportées à $< nécessitent un
appel système, vérifiez $! après une tentative de modification pour détecter d'éventuelles erreurs.

Mnémonique : c'est l'uid avec lequel tu es venu à partir de, si vous exécutez setuid.

$EFFECTIVE_USER_ID
$EUID
$> L'uid efficace de ce processus. Par exemple:

$< = $> ; # définir l'uid réel sur effectif
($<,$>) = ($>,$<); # échanger des uid réels et efficaces

Vous pouvez modifier à la fois l'uid effectif et l'uid réel en utilisant
"POSIX ::setuid()". Les modifications apportées à $> nécessitent un chèque à $ ! pour détecter tout éventuel
erreurs après une tentative de modification.

$ ne peuvent être échangés que sur les machines prenant en charge "setreuid()".

Mnémonique : c'est l'uid vers lequel vous êtes allé à, si vous exécutez setuid.

$SUBSCRIPT_SEPARATOR
$SOUS-SEP
$ ; Le séparateur d'indice pour l'émulation de tableau multidimensionnel. Si vous faites référence à un
élément de hachage comme

$foo{$x,$y,$z}

ça veut vraiment dire

$foo{join($;, $x, $y, $z)}

Mais ne mets pas

@foo{$x,$y,$z} # une tranche - notez le @

ce qui signifie

($foo{$x},$foo{$y},$foo{$z})

La valeur par défaut est "\034", identique à SUBSEP dans awk. Si vos clés contiennent des données binaires
il n'y a peut-être aucune valeur sûre pour $ ;.

Pensez à utiliser de "vrais" tableaux multidimensionnels comme décrit dans perllol.

Mnémonique : la virgule (le séparateur d'indice syntaxique) est un point-virgule.

$a
$b Variables de package spéciales lors de l'utilisation de "sort()", voir "sort" dans perlfunc. À cause de
cette particularité $a et $b n'a pas besoin d'être déclarée (en utilisant "use vars", ou
"our()") même en utilisant le pragma "strict 'vars'". Ne les lexicalisez pas avec
"my $a" ou "my $b" si vous souhaitez pouvoir les utiliser dans la comparaison "sort()"
bloc ou fonction.

%ENV Le hachage %ENV contient votre environnement actuel. La définition d'une valeur dans "ENV" change
l'environnement de tous les processus enfants que vous "forkez" par la suite.

Depuis la version 5.18.0, les clés et les valeurs stockées dans %ENV sont stringifiées.

mon $foo = 1 ;
$ENV{'bar'} = \$foo;
si( réf $ENV{'bar'} ) {
dites « Comportement avant 5.18.0 » ;
} Else {
dites « Comportement après 5.18.0 » ;
}

Auparavant, seuls les processus enfants recevaient des valeurs stringifiées :

mon $foo = 1 ;
$ENV{'bar'} = \$foo;

# Toujours imprimé 'non ref'
système ($ ^ X, '-e',
q/print ( ref $ENV{'bar'} ? 'ref' : 'non ref' ) /);

Cela se produit parce que vous ne pouvez pas réellement partager des structures de données arbitraires avec des utilisateurs étrangers.
procédés.

$OLD_PERL_VERSION
$] La révision, la version et la subversion de l'interpréteur Perl, représentées par un
décimal de la forme 5.XXXYYY, où XXX est la version / 1e3 et YYY est la
subversion / 1e6. Par exemple, Perl v5.10.1 serait "5.010001".

Cette variable peut être utilisée pour déterminer si l'interpréteur Perl exécutant un
le script est dans la bonne gamme de versions :

warn "Pas de PerlIO!\n" if $] lt '5.008';

Lors de la comparaison de $], les opérateurs de comparaison de chaînes sont très recommandéL’
les limitations inhérentes à la représentation binaire à virgule flottante peuvent parfois conduire à
comparaisons incorrectes pour certains nombres sur certaines architectures.

Voir aussi la documentation de « utiliser la VERSION » et « exiger la VERSION » pour une utilisation pratique.
moyen d'échouer si l'interpréteur Perl en cours d'exécution est trop ancien.

Voir "$^V" pour une représentation de la version Perl en tant qu'objet de version, qui
permet des comparaisons de chaînes plus flexibles.

Le principal avantage de $] par rapport à $^V est qu'il fonctionne de la même manière sur n'importe quelle version de
Perl. Les inconvénients sont qu'il ne peut pas être facilement comparé aux versions d'autres
formats (par exemple chaînes v littérales, "v1.2.3" ou objets de version) et numériques
les comparaisons peuvent parfois échouer ; c'est bon pour les vérifications de version littérale de chaîne et
mauvais pour comparer à une variable qui n'a pas été vérifiée.

Le formulaire $OLD_PERL_VERSION a été ajouté dans Perl v5.20.0 pour des raisons historiques mais
son utilisation est déconseillée. (Si votre raison d'utiliser $] est d'exécuter du code sur d'anciens Perl, alors
y faire référence sous le nom de $OLD_PERL_VERSION serait voué à l'échec.)

Mnémonique : Cette version de Perl est-elle dans la bonne parenthèse ?

$SYSTEM_FD_MAX
$^F Le descripteur de fichier système maximum, généralement 2. Les descripteurs de fichiers système sont
transmis aux processus "exec()", alors que les descripteurs de fichiers supérieurs ne le sont pas. Aussi,
lors d'un "open()", les descripteurs de fichiers système sont conservés même si le "open()"
échoue (les descripteurs de fichiers ordinaires sont fermés avant la tentative de "open()").
Le statut de fermeture d'exécution d'un descripteur de fichier sera décidé en fonction du
valeur de $^F lorsque le fichier, le canal ou le socket correspondant a été ouvert, et non l'heure
du "exec()".

@F Le tableau @F contient les champs de chaque ligne lus lorsque le mode autosplit est
allumé. Voir perlrun pour le -a changer. Ce tableau est spécifique au package et
doit être déclaré ou recevoir un nom de package complet s'il n'est pas dans le package principal lors de l'exécution
sous « vars » stricts ».

@INC Le tableau @INC contient la liste des endroits que "do EXPR", "exige" ou "utilisent"
les constructions recherchent leurs fichiers de bibliothèque. Il se compose initialement des arguments
à toute -I commutateurs de ligne de commande, suivis de la bibliothèque Perl par défaut, probablement
/usr/local/lib/perl, suivi de ".", pour représenter le répertoire actuel. ("."
ne sera pas ajouté si les contrôles de contamination sont activés, soit par "-T" soit par "-t".) Si
vous devez modifier ceci au moment de l'exécution, vous devez utiliser le pragma "use lib" pour obtenir le
bibliothèque dépendante de la machine correctement chargée également :

utilisez lib '/monchemin/libdir/';
utilisez SomeMod ;

Vous pouvez également insérer des hooks dans le système d'inclusion de fichiers en mettant du code Perl
directement dans @INC. Ces hooks peuvent être des références de sous-programmes, des références de tableaux ou
objets bénis. Voir "exiger" dans perlfunc pour plus de détails.

%INC Le hachage %INC contient des entrées pour chaque nom de fichier inclus via les champs "do", "require",
ou "utiliser" les opérateurs. La clé est le nom de fichier que vous avez spécifié (avec les noms de modules
convertis en noms de chemin), et la valeur est l'emplacement du fichier trouvé. Le
L'opérateur "require" utilise ce hachage pour déterminer si un fichier particulier a
déjà été inclus.

Si le fichier a été chargé via un hook (par exemple une référence de sous-programme, voir "require" dans
perlfunc pour une description de ces hooks), ce hook est par défaut inséré dans
%INC à la place d'un nom de fichier. Notez cependant que le hook peut avoir défini le %INC
entrée par elle-même pour fournir des informations plus spécifiques.

$INPLACE_EDIT
$^I La valeur actuelle de l'extension d'édition sur place. Utilisez "undef" pour désactiver sur place
édition.

Mnémonique : valeur de -i interrupteur.

$^M Par défaut, le manque de mémoire est une erreur fatale et irréparable. Toutefois, si
convenablement construit, Perl peut utiliser le contenu de $^M comme pool de mémoire de secours après
"mourir()". Supposons que votre Perl ait été compilé avec "-DPERL_EMERGENCY_SBRK" et
utilisé le malloc de Perl. Alors

$^M = 'un' x (1 << 16) ;

allouerait un tampon de 64 Ko à utiliser en cas d'urgence. Voir le INSTALLER déposer dans le
distribution Perl pour plus d'informations sur la façon d'ajouter des indicateurs de compilation C personnalisés lorsque
compiler Perl. Pour décourager l'utilisation occasionnelle de cette fonctionnalité avancée, il n'y a pas
Nom long anglais pour cette variable.

Cette variable a été ajoutée dans Perl 5.004.

$NOMOSI
$^O Le nom du système d'exploitation sous lequel cette copie de Perl a été construite, tel que
déterminé au cours du processus de configuration. Pour des exemples, voir "PLATEFORMES" dans
perlport.

La valeur est identique à $Config{'osname'}. Voir aussi Config et le -V commander-
commutateur de ligne documenté dans perlrun.

Sur les plateformes Windows, $^O n'est pas très utile : comme il s'agit toujours de "MSWin32", il
ne fait pas la différence entre 95/98/ME/NT/2000/XP/CE/.NET. Utiliser
"Win32 :: GetOSName ()" ou Win32 :: GetOSVersion() (voir Win32 et perlport) pour
distinguer les variantes.

Cette variable a été ajoutée dans Perl 5.003.

%SIG Le hachage %SIG contient des gestionnaires de signaux pour les signaux. Par exemple:

sous-gestionnaire { # le 1er argument est le nom du signal
mon($sig) = @_;
print "J'ai attrapé un SIG$sig--arrêt\n";
fermer(LOG);
sortie(0);
}

$SIG{'INT'} = \&handler;
$SIG{'QUITTER'} = \&handler;
...
$SIG{'INT'} = 'DEFAUT'; # restaurer l'action par défaut
$SIG{'QUIT'} = 'IGNORER'; # ignorer SIGQUIT

Utiliser la valeur « IGNORE » a généralement pour effet d'ignorer le signal, sauf
pour le signal "CHLD". Voir perlipc pour en savoir plus sur ce cas particulier.

Voici quelques autres exemples:

$SIG{"TUYAU"} = "Plombier"; # suppose main::Plombier (pas
# recommandé)
$SIG{"TUYAU"} = \&Plombier; # ça va; supposer le courant
# Plombier
$SIG{"TUYAU"} = *Plombier ; # quelque peu ésotérique
$SIG{"TUYAU"} = Plombier(); # oups, qu'a fait Plumber()
# retour??

Assurez-vous de ne pas utiliser de mots nus comme nom d'un gestionnaire de signal, de peur de vous
appelez-le par inadvertance.

Si votre système dispose de la fonction "sigaction()", alors les gestionnaires de signaux sont installés
En l'utilisant. Cela signifie que vous bénéficiez d’une gestion fiable du signal.

La politique de livraison par défaut des signaux a changé dans Perl v5.8.0 d'immédiate (également
appelés « dangereux ») à différés, également appelés « signaux sûrs ». Voir perlipc pour
pour en savoir davantage.

Certains hooks internes peuvent également être définis à l'aide du hachage %SIG. La routine indiquée
by $SIG{__WARN__} est appelé lorsqu'un message d'avertissement est sur le point d'être imprimé. Le
Le message d'avertissement est passé comme premier argument. La présence d'un "__WARN__"
Le hook provoque la suppression de l'impression ordinaire des avertissements sur "STDERR". Toi
peut l'utiliser pour enregistrer des avertissements dans une variable, ou transformer les avertissements en erreurs fatales,
comme ça:

local $SIG{__WARN__} = sub { die $_[0] };
évaluer $proggie ;

Comme le hook 'IGNORE' n'est pas supporté par "__WARN__", vous pouvez désactiver les avertissements
en utilisant le sous-programme vide :

local $SIG{__WARN__} = sous {} ;

La routine indiquée par $SIG{__DIE__} est appelée lorsqu'une exception fatale est sur le point
être jeté. Le message d'erreur est passé comme premier argument. Lorsqu'un
La routine de hook "__DIE__" est renvoyée, le traitement des exceptions continue comme il le ferait
avoir en l'absence du hook, à moins que la routine du hook elle-même ne se termine via un "goto
&sub", une sortie de boucle ou un "die()". Le gestionnaire "__DIE__" est explicitement désactivé
pendant l'appel, afin que vous puissiez mourir d'un gestionnaire "__DIE__". De même pour
"__AVERTIR__".

En raison d'un problème d'implémentation, le hook $SIG{__DIE__} est appelé même à l'intérieur d'un
"évaluation()". N'utilisez pas ceci pour réécrire une exception en attente dans $@, ou comme une bizarrerie
remplacez le remplacement de "CORE::GLOBAL::die()". Cette action étrange à un
la distance peut être corrigée dans une version ultérieure afin que $SIG{__DIE__} ne soit appelé que si
votre programme est sur le point de se terminer, comme c'était l'intention initiale. Toute autre utilisation est
obsolète.

Les gestionnaires "__DIE__"/"__WARN__" sont très spéciaux à un égard : ils peuvent être appelés
pour signaler les erreurs (probables) trouvées par l'analyseur. Dans un tel cas, l'analyseur peut être
dans un état incohérent, donc toute tentative d'évaluation du code Perl à partir d'un tel gestionnaire
entraînera probablement une erreur de segmentation. Cela signifie que les avertissements ou les erreurs qui
Le résultat de l'analyse de Perl doit être utilisé avec une extrême prudence, comme ceci :

nécessite Carp si défini $^S ;
Carp::confess("Quelque chose ne va pas") si défini &Carp::confess;
die "Quelque chose ne va pas, mais je n'ai pas pu charger Carp pour donner "
. "revenir en arrière...\n\t"
. "Pour voir la trace, essayez de démarrer Perl avec le commutateur -MCarp";

Ici, la première ligne chargera "Carp" à moins que c'est l'analyseur qui a appelé le
gestionnaire. La deuxième ligne imprimera la trace et mourra si "Carp" était disponible.
La troisième ligne ne sera exécutée que si "Carp" n'était pas disponible.

Devoir même penser à la variable $^S dans vos gestionnaires d'exceptions est tout simplement
faux. $SIG{__DIE__} tel qu'il est actuellement mis en œuvre invite à
traquer les erreurs. Évitez-le et utilisez un remplacement "END{}" ou CORE::GLOBAL::die
à la place.

Voir "die" dans perlfunc, "warn" dans perlfunc, "eval" dans perlfunc et les avertissements pour
Information additionnelle.

$BASETIME
$^T L'heure à laquelle le programme a commencé à s'exécuter, en secondes depuis l'époque (début
de 1970). Les valeurs renvoyées par le -M, -Aet -C les tests de fichiers sont basés sur ceci
valeur.

$PERL_VERSION
$^V La révision, la version et la subversion de l'interpréteur Perl, représentées par un
objet de version.

Cette variable est apparue pour la première fois dans Perl v5.6.0 ; les versions antérieures de Perl verront un
valeur indéfinie. Avant Perl v5.10.0, $^V était plutôt représenté comme une chaîne V.
qu'un objet de version.

$^V peut être utilisé pour déterminer si l'interpréteur Perl exécutant un script est en
la bonne gamme de versions. Par exemple:

warn "Hashes non randomisés !\n" si !$^V ou $^V lt v5.8.1

Alors que les objets de version surchargent la stringification, pour convertir de manière portable $^V en son
représentation sous forme de chaîne, utilisez la conversion "%vd" de "sprintf()", qui fonctionne à la fois
v-strings ou objets de version :

printf "la version est v%vd\n", $^V; # La version de Perl

Voir la documentation de « utiliser la VERSION » et « exiger la VERSION » pour un moyen pratique
échouer si l'interpréteur Perl en cours d'exécution est trop ancien.

Voir aussi $] pour une représentation décimale de la version Perl.

Le principal avantage de $^V par rapport à $] est que, pour Perl v5.10.0 ou version ultérieure, il surcharge
opérateurs, permettant une comparaison facile avec d'autres représentations de version (par exemple
décimal, chaîne v littérale, "v1.2.3" ou objets). L'inconvénient est qu'avant
vers la version 5.10.0, il ne s'agissait que d'une chaîne V littérale, qui ne peut pas être facilement imprimée ou
par rapport.

Mnémonique : utilisez ^V pour un objet de version.

${^WIN32_SLOPPY_STAT}
Si cette variable est définie sur une valeur vraie, alors "stat()" sous Windows n'essaiera pas de
ouvrez le fichier. Cela signifie que le nombre de liens ne peut pas être déterminé et que le fichier
les attributs peuvent être obsolètes s'il existe des liens physiques supplémentaires vers le fichier. Sur le
d'un autre côté, ne pas ouvrir le fichier est considérablement plus rapide, en particulier pour les fichiers sur
lecteurs réseau.

Cette variable pourrait être définie dans le sitecustomize.pl fichier pour configurer le local
Installation de Perl pour utiliser "bâclé" "stat()" par défaut. Voir la documentation pour
-f dans perlrun pour plus d'informations sur la personnalisation du site.

Cette variable a été ajoutée dans Perl v5.10.0.

$EXECUTABLE_NAME
$^X Le nom utilisé pour exécuter la copie actuelle de Perl, à partir de "argv[0]" de C ou (où
prise en charge) /proc/self/exe.

Selon le système d'exploitation hôte, la valeur de $^X peut être relative ou
chemin absolu du fichier programme Perl, ou peut être la chaîne utilisée pour appeler
perl mais pas le chemin du fichier programme Perl. De plus, la plupart des systèmes d'exploitation
autoriser l'appel de programmes qui ne sont pas dans la variable d'environnement PATH, donc là
Il n'y a aucune garantie que la valeur de $^X soit dans PATH. Pour VMS, la valeur peut ou peut
ne pas inclure de numéro de version.

Vous pouvez généralement utiliser la valeur de $^X pour ré-invoquer une copie indépendante du même
perl qui est actuellement en cours d'exécution, par exemple,

@first_run = `$^X -le "print int rand 100 for 1..100"`;

Mais rappelez-vous que tous les systèmes d'exploitation ne prennent pas en charge la duplication ou la capture du fichier.
sortie des commandes, cette instruction complexe peut donc ne pas être portable.

Il n'est pas prudent d'utiliser la valeur de $^X comme nom de chemin d'accès à un fichier, car certains opérateurs
les systèmes qui ont un suffixe obligatoire sur les fichiers exécutables ne nécessitent pas l'utilisation du
suffixe lors de l’appel d’une commande. Pour convertir la valeur de $^X en nom de chemin, utilisez
les déclarations suivantes :

# Créez un ensemble de noms de fichiers (pas de noms de commandes).
utilisez la configuration ;
mon $this_perl = $^X ;
if ($^O ne 'VMS') {
$this_perl .= $Config{_exe}
sauf si $this_perl =~ m/$Config{_exe}$/i;
}

Parce que de nombreux systèmes d'exploitation autorisent toute personne disposant d'un accès en lecture au programme Perl
fichier pour en faire une copie, patcher la copie, puis exécuter la copie, le
Un programmeur Perl soucieux de la sécurité doit prendre soin d'invoquer la copie installée
de Perl, pas la copie référencée par $^X. Les déclarations suivantes accomplissent cela
objectif, et produire un chemin d'accès qui peut être invoqué en tant que commande ou référencé en tant que
fichier.

utilisez la configuration ;
mon $secure_perl_path = $Config{perlpath} ;
if ($^O ne 'VMS') {
$secure_perl_path .= $Config{_exe}
sauf si $secure_perl_path =~ m/$Config{_exe}$/i;
}

Variables en relation à Standard expressions
La plupart des variables spéciales liées aux expressions régulières sont des effets secondaires. Ensembles Perl
ces variables lorsqu'il y a une correspondance réussie, vous devez donc vérifier le résultat de la correspondance
avant de les utiliser. Par exemple:

si( /P(A)TT(ER)N/ ) {
print "J'ai trouvé 1$ et 2$\n";
}

Ces variables sont en lecture seule et à portée dynamique, sauf indication contraire.

La nature dynamique des variables d'expression régulière signifie que leur valeur est limitée
au bloc dans lequel ils se trouvent, comme le démontre ce morceau de code :

mon $outer = 'Wallace et Grommit' ;
mon $inner = 'Mutt et Jeff' ;

mon $pattern = qr/(\S+) et (\S+)/;

sub show_n { print "\$1 vaut 1$; \$2 vaut 2$\n" }

{
EXTÉRIEUR:
show_n() si $outer =~ m/$pattern/;

INTÉRIEUR: {
show_n() si $inner =~ m/$pattern/;
}

show_n();
}

La sortie montre que dans le bloc "OUTER", les valeurs de $1 et $2 proviennent du
match contre $externe. À l'intérieur du bloc "INNER", les valeurs de $1 et $2 proviennent du
correspondre à $inner, mais seulement jusqu'à la fin du bloc (c'est-à-dire la portée dynamique). Après
le bloc "INNER" se termine, les valeurs de $1 et $2 reviennent aux valeurs de la correspondance
contre $outer même si nous n'avons pas fait d'autre match :

1 $ représente Wallace ; 2 $ c'est Grommit
1 $ c'est Mutt ; 2 $ c'est Jeff
1 $ représente Wallace ; 2 $ c'est Grommit

Performances vous aider à faire face aux problèmes qui vous perturbent

Traditionnellement en Perl, toute utilisation de l'une des trois variables "$`", $& ou "$'" (ou leur
"utiliser les équivalents anglais") n'importe où dans le code, a provoqué tous les modèles réussis ultérieurs
matches pour faire une copie de la chaîne correspondante, au cas où le code pourrait accéder ultérieurement
une de ces variables. Cela a imposé une pénalité considérable en termes de performances sur l'ensemble de la
programme, donc généralement l’utilisation de ces variables a été découragée.

Dans Perl 5.6.0, les tableaux dynamiques "@-" et "@+" ont été introduits pour fournir les indices de
des matchs réussis. Vous pourriez donc par exemple faire ceci :

$str =~ /motif/;

imprimer $`, $&, $'; # mauvais : performances dégradées

print # good : aucun impact sur les performances
sous-str($str, 0, $-[0]),
substr($str, $-[0], $+[0]-$-[0]),
substr($str, $+[0]);

Dans Perl 5.10.0, l'indicateur d'opérateur de correspondance "/p" et "${^PREMATCH}", "${^MATCH}", et
Des variables "${^POSTMATCH}" ont été introduites, qui vous permettaient de subir uniquement les pénalités
sur les modèles marqués de "/p".

À partir de Perl 5.18.0, Perl a commencé à noter la présence de chacune des trois variables
séparément, et copié uniquement la partie de la chaîne requise ; donc dans

$` ; $&; "abcdefgh" =~ /d/

perl ne copierait que la partie "abcd" de la chaîne. Cela pourrait faire une grande différence dans
quelque chose comme

$str = 'x' x 1_000_000 ;
$&; # oups
$str =~ /x/g # un caractère copié un million de fois, pas un million de caractères

Dans Perl 5.20.0, un nouveau système de copie sur écriture a été activé par défaut, ce qui corrige finalement tous les problèmes.
problèmes de performances avec ces trois variables et les rend sûrs à utiliser n'importe où.

Les modules "Devel::NYTProf" et "Devel::FindAmpersand" peuvent vous aider à trouver des utilisations pour ces derniers.
variables de correspondance problématiques dans votre code.

$<chiffres> (1 $, 2 $, ...)
Contient le sous-modèle de l'ensemble correspondant de parenthèses de capture de
la dernière correspondance de modèle réussie, sans compter les modèles correspondant dans les blocs imbriqués
qui ont déjà été quittés.

Ces variables sont en lecture seule et à portée dynamique.

Mnémonique : comme \digits.

$ MATCH
$& La chaîne correspondant à la dernière correspondance de modèle réussie (sans compter les correspondances
caché dans un BLOC ou "eval()" entouré par le BLOC actuel).

Voir « Problèmes de performances » ci-dessus pour connaître les conséquences graves de l'utilisation de
cette variable (même une fois) dans votre code.

Cette variable est en lecture seule et à portée dynamique.

Mnémonique : comme "&" dans certains éditeurs.

${^MATCH}
Ceci est similaire à $& ($MATCH) sauf que cela n'entraîne pas de performances
pénalité associée à cette variable.

Voir « Problèmes de performances » ci-dessus.

Dans Perl v5.18 et versions antérieures, il est uniquement garanti de renvoyer une valeur définie lorsque
le modèle a été compilé ou exécuté avec le modificateur "/p". Dans Perl v5.20, le
Le modificateur "/p" ne fait rien, donc "${^MATCH}" fait la même chose que $MATCH.

Cette variable a été ajoutée dans Perl v5.10.0.

Cette variable est en lecture seule et à portée dynamique.

$PRÉMATCH
$` La chaîne précédant tout ce qui correspond à la dernière correspondance de modèle réussie,
sans compter les correspondances cachées dans un BLOC ou "eval" entouré par le courant
BLOQUER.

Voir « Problèmes de performances » ci-dessus pour connaître les conséquences graves de l'utilisation de
cette variable (même une fois) dans votre code.

Cette variable est en lecture seule et à portée dynamique.

Mnémonique : "`" précède souvent une chaîne entre guillemets.

${^PREMATCH}
Ceci est similaire à "$`" ($PREMATCH) sauf que cela n'entraîne pas de performances
pénalité associée à cette variable.

Voir « Problèmes de performances » ci-dessus.

Dans Perl v5.18 et versions antérieures, il est uniquement garanti de renvoyer une valeur définie lorsque
le modèle a été compilé ou exécuté avec le modificateur "/p". Dans Perl v5.20, le
Le modificateur "/p" ne fait rien, donc "${^PREMATCH}" fait la même chose que $PREMATCH.

Cette variable a été ajoutée dans Perl v5.10.0.

Cette variable est en lecture seule et à portée dynamique.

$POSTMATCH
$' La chaîne suivant ce qui correspond à la dernière correspondance de modèle réussie
(sans compter les correspondances cachées dans un BLOC ou "eval()" entouré par le
BLOC actuel). Exemple:

local $_ = 'abcdefghi';
/déf/;
imprimer "$`:$&:$'\n" ; # imprime abc:def:ghi

Voir « Problèmes de performances » ci-dessus pour connaître les conséquences graves de l'utilisation de
cette variable (même une fois) dans votre code.

Cette variable est en lecture seule et à portée dynamique.

Mnémonique : "'" suit souvent une chaîne entre guillemets.

${^POSTMATCH}
Ceci est similaire à "$'" ($POSTMATCH) sauf qu'il n'entraîne pas de performances
pénalité associée à cette variable.

Voir « Problèmes de performances » ci-dessus.

Dans Perl v5.18 et versions antérieures, il est uniquement garanti de renvoyer une valeur définie lorsque
le modèle a été compilé ou exécuté avec le modificateur "/p". Dans Perl v5.20, le
Le modificateur "/p" ne fait rien, donc "${^POSTMATCH}" fait la même chose que $POSTMATCH.

Cette variable a été ajoutée dans Perl v5.10.0.

Cette variable est en lecture seule et à portée dynamique.

$LAST_PAREN_MATCH
$+ Le texte correspondant à la dernière parenthèse du dernier modèle de recherche réussi. Ce
est utile si vous ne savez pas lequel d'un ensemble de modèles alternatifs correspond.
Par exemple :

/Version : (.*)|Révision : (.*)/ && ($rev = $+);

Cette variable est en lecture seule et à portée dynamique.

Mnémonique : soyez positif et tourné vers l’avenir.

$LAST_SUBMATCH_RESULT
$^N Le texte correspondant au groupe utilisé le plus récemment fermé (c'est-à-dire le groupe avec le
parenthèse fermante la plus à droite) du dernier modèle de recherche réussi.

Ceci est principalement utilisé dans les blocs "(?{...})" pour examiner le texte récemment
correspondait. Par exemple, pour capturer efficacement du texte dans une variable (en plus de
1$, 2$, etc.), remplacer "(...)" par

(?:(...)(?{ $var = $^N }))

En définissant puis en utilisant $var de cette manière, vous n'avez plus à vous soucier de
exactement de quel ensemble de parenthèses numérotées il s'agit.

Cette variable a été ajoutée dans Perl v5.8.0.

Mnémonique : la (éventuellement) parenthèse imbriquée qui s'est fermée la plus récemment.

@LAST_MATCH_END
@+ Ce tableau contient les décalages des extrémités des dernières sous-correspondances réussies dans le
portée dynamique actuellement active. $+[0] est le décalage dans la chaîne de la fin de
tout le match. C'est la même valeur que celle renvoyée par la fonction "pos" lorsque
appelé la variable à laquelle a été comparée. Le nle ème élément de ce tableau
détient le décalage du nème sous-correspondance, donc $+[1] est le décalage après où se termine $1,
$+[2] le décalage au-delà de l'endroit où se termine $2, et ainsi de suite. Vous pouvez utiliser $#+ pour déterminer comment
de nombreux sous-groupes participaient au dernier match réussi. Voir les exemples donnés pour le
Variable "@-".

Cette variable a été ajoutée dans Perl v5.6.0.

%LAST_PAREN_MATCH
%+ Semblable à "@+", le hachage "%+" permet d'accéder aux tampons de capture nommés, si
ils existent, dans la dernière correspondance réussie dans la portée dynamique actuellement active.

Par exemple, $+{foo} équivaut à 1 $ après la correspondance suivante :

'foo' =~ /(? foo)/;

Les clés du hachage "%+" listent uniquement les noms des buffers qui ont capturé (et
qui sont ainsi associés à des valeurs définies).

Le comportement sous-jacent de "%+" est fourni par Tie::Hash::NamedCapture
module.

Remarque: "%-" et "%+" sont des vues liées dans un hachage interne commun associé au
dernière expression régulière réussie. Mélangeant donc l'accès itératif à ceux-ci via
"chacun" peut avoir des résultats imprévisibles. De même, si le dernier match réussi
changements, alors les résultats peuvent être surprenants.

Cette variable a été ajoutée dans Perl v5.10.0.

Cette variable est en lecture seule et à portée dynamique.

@LAST_MATCH_START
@- "$-[0]" est le décalage du début de la dernière correspondance réussie. "$-["n"]" est le
décalage du début de la sous-chaîne correspondant à n-ième sous-modèle, ou undef si le
le sous-modèle ne correspondait pas.

Ainsi, après une correspondance contre $_, $& coïncide avec "substr $_, $-[0], $++[0] -
$-[0]". De même, $n coïncide avec "substr $_, $-[n], $+[n] - $-[n]" si "$-[n]"
est défini et $+ coïncide avec "substr $_, $-[$#-], $+[$#-] - $-[$#-]". Un
peut utiliser "$#-" pour trouver le dernier sous-groupe correspondant dans la dernière correspondance réussie.
Comparez avec $#+, le nombre de sous-groupes dans l'expression régulière. Comparer
avec "@+".

Ce tableau contient les décalages des débuts des dernières sous-correspondances réussies
dans la portée dynamique actuellement active. "$-[0]" est le décalage dans la chaîne de
le début de tout le match. Le nle ème élément de ce tableau contient le décalage
du système nème sous-correspondance, donc "$-[1]" est le décalage où commence $1, "$-[2]" le décalage
où commence 2 $, et ainsi de suite.

Après une correspondance avec une variable $var :

"$`" est identique à "substr($var, 0, $-[0])"
$& est identique à "substr($var, $-[0], $+[0] - $-[0])"
"$'" est identique à "substr($var, $+[0])"
$1 est identique à "substr($var, $-[1], $+[1] - $-[1])"
$2 est identique à "substr($var, $-[2], $+[2] - $-[2])"
$3 est identique à "substr($var, $-[3], $+[3] - $-[3])"

Cette variable a été ajoutée dans Perl v5.6.0.

%LAST_MATCH_START
%- Semblable à "%+", cette variable permet d'accéder aux groupes de capture nommés dans le
dernière correspondance réussie dans la portée dynamique actuellement active. À chaque capture
nom de groupe trouvé dans l'expression régulière, il associe une référence à un tableau
contenant la liste des valeurs capturées par tous les tampons portant ce nom (s'il y a
il y en a plusieurs), dans l'ordre où ils apparaissent.

Voici un exemple:

if ('1234' =~ /(? 1)(? 2)(? 3)(? 4)/) {
foreach mon $bufname (clés de tri %-) {
mon $ary = $-{$bufname} ;
foreach mon $idx (0..$#$ary) {
print "\$-{$bufname}[$idx] : ",
(défini($ary->[$idx])
? "'$ary->[$idx]'"
: "undef"),
"\n" ;
}
}
}

imprimerait:

$-{A}[0] : '1'
$-{A}[1] : '3'
$-{B}[0] : '2'
$-{B}[1] : '4'

Les clés du hachage "%-" correspondent à tous les noms de tampons trouvés dans le fichier régulier
expression.

Le comportement de "%-" est implémenté via le module Tie::Hash::NamedCapture.

Remarque: "%-" et "%+" sont des vues liées dans un hachage interne commun associé au
dernière expression régulière réussie. Mélangeant donc l'accès itératif à ceux-ci via
"chacun" peut avoir des résultats imprévisibles. De même, si le dernier match réussi
changements, alors les résultats peuvent être surprenants.

Cette variable a été ajoutée dans Perl v5.10.0.

Cette variable est en lecture seule et à portée dynamique.

$LAST_REGEXP_CODE_RESULT
$^R Le résultat de l'évaluation de la dernière expression régulière "(?{ code })" réussie
assertion (voir perlre). Peut être écrit.

Cette variable a été ajoutée dans Perl 5.005.

${^RE_DEBUG_FLAGS}
La valeur actuelle des indicateurs de débogage des regex. Réglé sur 0 pour aucune sortie de débogage, même
lorsque le module "re 'debug'" est chargé. Voir re pour plus de détails.

Cette variable a été ajoutée dans Perl v5.10.0.

${^RE_TRIE_MAXBUF}
Contrôle la manière dont certaines optimisations de regex sont appliquées et la quantité de mémoire qu'elles
utiliser. Cette valeur par défaut est 65536 ce qui correspond à un espace temporaire de 512 Ko
cache. Réglez-le sur une valeur plus élevée pour échanger de la mémoire contre de la vitesse lors de la correspondance de grandes
alternances. Réglez-le sur une valeur inférieure si vous souhaitez que les optimisations soient aussi
conservateur de mémoire possible mais se produit quand même, et définissez-le sur une valeur négative
pour empêcher l’optimisation et conserver le plus de mémoire. Dans des situations normales
cette variable ne devrait pas vous intéresser.

Cette variable a été ajoutée dans Perl v5.10.0.

Variables en relation à descripteurs de fichiers
Les variables qui dépendent du descripteur de fichier actuellement sélectionné peuvent être définies en appelant un
méthode objet appropriée sur l'objet "IO::Handle", bien que cela soit moins efficace que
en utilisant les variables intégrées régulières. (Les lignes de résumé ci-dessous contiennent le mot
POIGNÉE.) Vous devez d’abord dire

utiliser IO::Handle;

après quoi vous pouvez utiliser soit

méthode HANDLE EXPR

ou plus en toute sécurité,

HANDLE->méthode (EXPR)

Chaque méthode renvoie l'ancienne valeur de l'attribut "IO::Handle". Les méthodes prennent chacune un
EXPR facultatif, qui, s'il est fourni, spécifie la nouvelle valeur de l'attribut "IO::Handle"
Dans la question. Si elles ne sont pas fournies, la plupart des méthodes ne font rien sur la valeur actuelle - à l'exception de
"autoflush()", qui prendra la valeur 1 pour vous, juste pour être différent.

Le chargement dans la classe "IO::Handle" étant une opération coûteuse, vous devez apprendre comment
pour utiliser les variables intégrées régulières.

Quelques-unes de ces variables sont considérées comme « en lecture seule ». Cela signifie que si vous essayez d'attribuer
à cette variable, directement ou indirectement via une référence, vous déclencherez un run-
exception temporelle.

Vous devez être très prudent lorsque vous modifiez les valeurs par défaut de la plupart des variables spéciales
décrit dans ce document. Dans la plupart des cas, vous souhaitez localiser ces variables avant
en les modifiant, car si vous ne le faites pas, le changement peut affecter d'autres modules qui s'appuient sur le
valeurs par défaut des variables spéciales que vous avez modifiées. C'est l'un des bons
façons de lire le fichier entier en même temps :

ouvre mon $fh, "<", "foo" ou meurs $!;
$/local ; # activer le mode slurp localisé
mon $content = <$fh> ;
fermer $fh ;

Mais le code suivant est assez mauvais :

ouvre mon $fh, "<", "foo" ou meurs $!;
undef $/; # activer le mode slurp
mon $content = <$fh> ;
fermer $fh ;

puisqu'un autre module peut vouloir lire les données d'un fichier dans le "mode ligne" par défaut,
donc si le code que nous venons de présenter a été exécuté, la valeur globale de $/ est désormais
modifié pour tout autre code exécuté dans le même interpréteur Perl.

Habituellement, lorsqu'une variable est localisée, vous voulez vous assurer que ce changement affecte la
portée la plus courte possible. Donc, à moins que vous ne soyez déjà à l'intérieur d'un court bloc "{}", vous
devriez en créer un vous-même. Par exemple:

mon $content = '';
ouvre mon $fh, "<", "foo" ou meurs $!;
{
$/ locale ;
$contenu = <$fh> ;
}
fermer $fh ;

Voici un exemple de la façon dont votre propre code peut être brisé :

pour ( 1..3 ){
$\ = "\r\n" ;
méchant_break();
imprimer "$_" ;
}

sous méchant_break {
$\ = "\f" ;
# faire quelque chose avec $_
}

Vous vous attendez probablement à ce que ce code imprime l'équivalent de

"1\r\n2\r\n3\r\n"

mais à la place vous obtenez :

"1\f2\f3\f"

Pourquoi? Parce que "nasty_break()" modifie "$\" sans le localiser au préalable. La valeur que vous définissez
dans "nasty_break()" est toujours là à votre retour. Le correctif consiste à ajouter "local()" pour que le
la valeur ne s'échappe pas de "nasty_break()" :

local $\ = "\f" ;

Il est facile de remarquer le problème dans un exemple aussi court, mais dans un code plus compliqué, vous
recherchez des problèmes si vous ne localisez pas les modifications apportées aux variables spéciales.

$ARGV Contient le nom du fichier courant lors de la lecture depuis "<>".

@ARGV Le tableau @ARGV contient les arguments de ligne de commande destinés au script.
$#ARGV est généralement le nombre d'arguments moins un, car $ARGV[0] est le
premier argument, pas le nom de la commande du programme lui-même. Voir "$0" pour la commande
nom.

ARGV Le descripteur de fichier spécial qui parcourt les noms de fichiers de ligne de commande dans @ARGV.
Généralement écrit comme descripteur de fichier nul dans l'opérateur d'angle "<>". Noter que
actuellement « ARGV » n'a son effet magique qu'au sein de l'opérateur « <> » ; autre part
il s'agit simplement d'un simple descripteur de fichier correspondant au dernier fichier ouvert par "<>". Dans
particulier, en passant "\*ARGV" comme paramètre à une fonction qui attend un
filehandle peut ne pas amener votre fonction à lire automatiquement le contenu de tous
les fichiers dans @ARGV.

ARGVOUT Le descripteur de fichier spécial qui pointe vers le fichier de sortie actuellement ouvert lors de l'exécution
traitement d'édition sur place avec -i. Utile lorsque vous devez faire beaucoup d’insertions
et je ne veux pas continuer à modifier $_. Voir perlrun pour le -i interrupteur.

IO::Handle->output_field_separator( EXPR)
$OUTPUT_FIELD_SEPARATOR
$OFS
$, Le séparateur de champ de sortie pour l'opérateur d'impression. Si définie, cette valeur est
imprimé entre chacun des arguments de print. La valeur par défaut est "undef".

Vous ne pouvez pas appeler "output_field_separator()" sur un handle, uniquement en tant que méthode statique.
Voir IO :: Handle.

Mnémonique : ce qui est imprimé lorsqu'il y a un "," dans votre instruction d'impression.

HANDLE->input_line_number( EXPR)
$INPUT_LINE_NUMBER
$NR
$. Numéro de ligne actuel du dernier descripteur de fichier consulté.

Chaque descripteur de fichier en Perl compte le nombre de lignes qui y ont été lues.
(En fonction de la valeur de $/, l'idée de Perl sur ce qui constitue une ligne peut ne pas être
correspond au vôtre.) Lorsqu'une ligne est lue à partir d'un descripteur de fichier (via "readline()" ou "<>"),
ou lorsque "tell()" ou "seek()" est appelé, $. devient un alias pour la ligne
compteur pour ce descripteur de fichier.

Vous pouvez ajuster le compteur en l'attribuant à $., mais cela ne déplacera pas réellement le
chercher un pointeur. Localisation $. vont pas localiser le descripteur de fichier en ligne compter.
Au lieu de cela, il localisera la notion perl de quel descripteur de fichier $. est actuellement
alias.

$. est réinitialisé lorsque le descripteur de fichier est fermé, mais pas lorsqu'un descripteur de fichier ouvert est
rouvert sans "close()" intermédiaire. Pour plus de détails, voir « Opérateurs d'E/S ».
en perlop. Parce que "<>" ne ferme jamais explicitement, les numéros de ligne augmentent
dans les fichiers "ARGV" (mais voir les exemples dans "eof" dans perlfunc).

Vous pouvez également utiliser "HANDLE->input_line_number(EXPR)" pour accéder au compteur de lignes pour
un descripteur de fichier donné sans avoir à vous soucier du dernier descripteur auquel vous avez accédé.

Mnémonique : de nombreux programmes utilisent "." pour signifier le numéro de ligne actuel.

IO::Handle->input_record_separator( EXPR)
$INPUT_RECORD_SEPARATOR
$ RS
$/ Le séparateur d'enregistrement d'entrée, nouvelle ligne par défaut. Cela influence l'idée de Perl de
ce qu'est une "ligne". Fonctionne comme awkLa variable RS de , y compris le traitement des lignes vides comme
un terminateur s'il est défini sur la chaîne nulle (une ligne vide ne peut contenir aucun espace ou
onglets). Vous pouvez le définir sur une chaîne à plusieurs caractères pour correspondre à une chaîne à plusieurs caractères
terminateur, ou sur "undef" pour lire jusqu'à la fin du fichier. Le définir sur "\n\n"
signifie quelque chose de légèrement différent du réglage sur "", si le fichier contient
lignes vides consécutives. Le réglage sur "" traitera deux ou plusieurs vides consécutifs
lignes comme une seule ligne vide. Le réglage sur "\n\n" supposera aveuglément que le prochain
Le caractère saisi appartient au paragraphe suivant, même s'il s'agit d'une nouvelle ligne.

$/ local ; # activer le mode "slurp"
local $_ = ; # fichier entier maintenant ici
s/\n[ \t]+/ /g;

N'oubliez pas : la valeur de $/ est une chaîne, pas une expression régulière. awk ça doit être mieux pour
quelque chose. :-)

Définir $/ sur une référence à un entier, un scalaire contenant un entier ou un scalaire
qui est convertible en entier tentera de lire les enregistrements au lieu des lignes,
la taille maximale de l'enregistrement étant le nombre entier de caractères référencé.
Donc ça:

local $/ = \32768 ; # ou \"32768", ou \$var_containing_32768
ouvrez mon $fh, "<", $myfile ou mourez $!;
local $_ = <$fh> ;

lira un enregistrement de 32768 XNUMX caractères maximum à partir de $fh. Si tu n'es pas
lecture à partir d'un fichier orienté enregistrement (ou votre système d'exploitation ne dispose pas de
fichiers), vous obtiendrez probablement un ensemble complet de données à chaque lecture. Si un enregistrement
est plus grande que la taille d'enregistrement que vous avez définie, vous récupérerez l'enregistrement en morceaux.
Essayer de définir la taille d'enregistrement sur zéro ou moins est obsolète et entraînera $/ à
avoir la valeur "undef", ce qui provoquera une lecture dans le (reste du) tout
fichier.

Depuis la version 5.19.9, définir $/ sur toute autre forme de référence entraînera une erreur fatale.
exception. Ceci est en préparation pour prendre en charge de nouvelles façons de définir $/ à l'avenir.

Sur VMS uniquement, les lectures d'enregistrement contournent les couches PerlIO et toute mise en mémoire tampon associée, donc
vous ne devez pas mélanger des lectures avec et sans enregistrement sur le même descripteur de fichier. Mode d'enregistrement
se mélange avec le mode ligne uniquement lorsque la même couche tampon est utilisée pour les deux modes.

Vous ne pouvez pas appeler "input_record_separator()" sur un handle, uniquement en tant que méthode statique.
Voir IO :: Handle.

Voir aussi "Nouvelles lignes" dans Perlport. Voir également « $. ».

Mnémonique : / délimite les limites des lignes lors de la citation de poésie.

IO::Handle->output_record_separator( EXPR)
$OUTPUT_RECORD_SEPARATOR
$ORS
$\ Le séparateur d'enregistrement de sortie pour l'opérateur d'impression. Si elle est définie, cette valeur est
imprimé après le dernier des arguments de print. La valeur par défaut est "undef".

Vous ne pouvez pas appeler "output_record_separator()" sur un handle, uniquement en tant que méthode statique.
Voir IO :: Handle.

Mnémonique : vous définissez "$\" au lieu d'ajouter "\n" à la fin de l'impression. Aussi, c'est
tout comme $/, mais c'est ce que vous récupérez de Perl.

POIGNÉE->flush automatique ( EXPR )
$OUTPUT_AUTOFLUSH
$| S'il est défini sur une valeur différente de zéro, force un vidage immédiatement et après chaque écriture ou impression sur le
canal de sortie actuellement sélectionné. La valeur par défaut est 0 (que le
le canal est réellement mis en mémoire tampon par le système ou non ; $| vous indique seulement si vous avez
a demandé explicitement à Perl de vider après chaque écriture). STDOUT sera généralement la ligne
mis en mémoire tampon si la sortie est vers le terminal et bloc mis en mémoire tampon dans le cas contraire. Définir ceci
La variable est utile principalement lorsque vous effectuez une sortie vers un tube ou un socket, tel que
lorsque vous exécutez un programme Perl sous rsh et je veux voir le résultat tel qu'il est
événement. Cela n'a aucun effet sur la mise en mémoire tampon des entrées. Voir "getc" dans perlfunc pour
que. Voir "select" dans perlfunc pour savoir comment sélectionner le canal de sortie. Voir également
IO::Poignée.

Mnémonique : quand vous voulez que vos tuyaux soient très chauds.

${^LAST_FH}
Cette variable en lecture seule contient une référence au descripteur de fichier lu en dernier lieu. C'est
défini par " ", " readline ", " tell ", " eof " et " seek ". C'est le même handle
ce $. et "tell" et "eof" sans utiliser d'arguments. C'est aussi le manche utilisé
quand Perl ajoute ", ligne 1" à un message d'erreur ou d'avertissement.

Cette variable a été ajoutée dans Perl v5.18.0.

Variables en relation à formats

Les variables spéciales pour les formats sont un sous-ensemble de celles pour les descripteurs de fichiers. Voir perlform pour
plus d'informations sur les formats Perl.

$ACCUMULATEUR
$^A La valeur actuelle de l'accumulateur "write()" pour les lignes "format()". Un format
contient des appels "formline()" qui mettent leur résultat dans $^A. Après avoir appelé son
format, "write()" imprime le contenu de $^A et se vide. Donc tu n'as jamais vraiment
voyez le contenu de $^A sauf si vous appelez vous-même "formline()" et que vous le regardez ensuite.
Voir perlform et "formline PICTURE,LIST" dans perlfunc.

IO::Handle->format_formfeed(EXPR)
$FORMAT_FORMFEED
$^L Quels formats de sortie sous forme de saut de formulaire. La valeur par défaut est "\f".

Vous ne pouvez pas appeler "format_formfeed()" sur un handle, uniquement en tant que méthode statique. Voir
IO::Poignée.

HANDLE->format_page_number(EXPR)
$FORMAT_PAGE_NUMBER
$% Le numéro de page actuel du canal de sortie actuellement sélectionné.

Mnémonique : "%" est le numéro de page dans nroff.

HANDLE->format_lines_left(EXPR)
$FORMAT_LINES_LEFT
$- Le nombre de lignes restantes sur la page du canal de sortie actuellement sélectionné.

Mnémonique : lines_on_page - lines_printed.

IO::Handle->format_line_break_characters EXPR
$FORMAT_LINE_BREAK_CHARACTERS
$ : le jeu de caractères actuel après lequel une chaîne peut être brisée pour être remplie
champs de continuation (commençant par "^") dans un format. La valeur par défaut est " \n-", pour
saut sur un espace, une nouvelle ligne ou un trait d'union.

Vous ne pouvez pas appeler "format_line_break_characters()" sur un handle, uniquement en tant que statique
méthode. Voir IO :: Handle.

Mnémonique : un « deux-points » en poésie est une partie d'un vers.

HANDLE->format_lines_per_page(EXPR)
$FORMAT_LINES_PER_PAGE
$= La longueur de page actuelle (lignes imprimables) de la sortie actuellement sélectionnée
canal. La valeur par défaut est 60.

Mnémonique : = comporte des lignes horizontales.

HANDLE->format_top_name(EXPR)
$FORMAT_TOP_NAME
$^ Le nom du format de haut de page actuel pour la sortie actuellement sélectionnée
canal. La valeur par défaut est le nom du descripteur de fichier avec "_TOP" ajouté. Pour
Par exemple, le nom principal du format par défaut pour le descripteur de fichier "STDOUT" est "STDOUT_TOP".

Mnémonique : pointe vers le haut de la page.

HANDLE->format_name(EXPR)
$FORMAT_NAME
$~ Le nom du format de rapport actuel pour le canal de sortie actuellement sélectionné.
Le nom du format par défaut est le même que le nom du descripteur de fichier. Par exemple, le
le nom de format par défaut du descripteur de fichier "STDOUT" est simplement "STDOUT".

Mnémonique : frère de $^.

Erreur Variables
Les variables $@, $!, $^E et $? contenir des informations sur différents types d'erreurs
conditions pouvant apparaître lors de l’exécution d’un programme Perl. Les variables sont affichées
ordonné par la "distance" entre le sous-système qui a signalé l'erreur et le Perl
processus. Elles correspondent aux erreurs détectées par l'interpréteur Perl, la bibliothèque C, en fonctionnement
système ou un programme externe, respectivement.

Pour illustrer les différences entre ces variables, considérons le Perl suivant
expression, qui utilise une chaîne entre guillemets simples. Après l'exécution de cette instruction, perl
peut avoir défini les quatre variables d'erreur spéciales :

évaluer q{
ouvrez mon $pipe, "/cdrom/install |" ou mourir $!;
mon @res = <$pipe> ;
fermez $pipe ou mourez "bad pipe: $?, $!";
};

Lorsque Perl exécute l'expression "eval()", il traduit "open()", " ", et
"fermer" les appels dans la bibliothèque d'exécution C et ensuite vers le noyau du système d'exploitation. perl
définit $ ! au "errno" de la bibliothèque C si l'un de ces appels échoue.

$@ est défini si la chaîne à "évaluer" n'a pas été compilée (cela peut arriver si "ouvert" ou
"close" ont été importés avec de mauvais prototypes), ou si du code Perl exécuté lors de l'évaluation
"décédé. Dans ces cas, la valeur de $@ est l'erreur de compilation, ou l'argument pour "mourir"
(qui interpolera $! et $?). (Voir aussi Fatal, cependant.)

Sous quelques systèmes d'exploitation, $^E peut contenir un indicateur d'erreur plus détaillé, comme dans
dans ce cas, "le plateau du CD-ROM n'est pas fermé". Systèmes qui ne prennent pas en charge les messages d'erreur étendus
laissez $^E identique à $!.

Enfin, $ ? peut être réglé sur une valeur non nulle si le programme externe /cdrom/installer échoue. Le
les huit bits supérieurs reflètent les conditions d'erreur spécifiques rencontrées par le programme (le
valeur "exit()" du programme). Les huit bits inférieurs reflètent le mode de défaillance, comme le signal
informations sur les décès et les vidages de noyau. Voir attendez(2) pour plus de détails. Contrairement à $! et $^E,
qui sont définis uniquement si une condition d'erreur est détectée, la variable $? est défini à chaque "attente"
ou pipe "close", écrasant l'ancienne valeur. Cela ressemble plus à $@, qui à chaque "eval()"
est toujours déterminé à l'échec et résolu au succès.

Pour plus de détails, consultez les descriptions individuelles sur $@, $!, $^E et $?.

${^CHILD_ERROR_NATIVE}
Le statut natif renvoyé par la dernière commande pipe close, backtick ("``"),
appel réussi à "wait()" ou "waitpid()", ou depuis l'opérateur "system()". Sur
Sur les systèmes de type POSIX, cette valeur peut être décodée avec WIFEXITED, WEXITSTATUS,
Fonctions WIFSIGNALED, WTERMSIG, WIFSTOPPED, WSTOPSIG et WIFCONTINUED fournies par
le module POSIX.

Sous VMS, cela reflète l'état de sortie réel de VMS ; c'est à dire que c'est la même chose que $ ? quand
le pragma "utiliser le 'statut' de vmsish" est en vigueur.

Cette variable a été ajoutée dans Perl v5.10.0.

$EXTENDED_OS_ERROR
$^E Informations d'erreur spécifiques au système d'exploitation actuel. Pour le moment, ceci
diffère de $! uniquement sous VMS, OS/2 et Win32 (et pour MacPerl). Sur tous les autres
plates-formes, $^E est toujours identique à $!.

Sous VMS, $^E fournit la valeur d'état VMS de la dernière erreur système. C'est
des informations plus spécifiques sur la dernière erreur système que celles fournies par $!.
Ceci est particulièrement important lorsque $! est réglé sur EVMSERR.

Sous OS/2, $^E est défini sur le code d'erreur du dernier appel à l'API OS/2, soit via
CRT, ou directement depuis Perl.

Sous Win32, $^E renvoie toujours les dernières informations d'erreur signalées par Win32
appelez "GetLastError()" qui décrit la dernière erreur depuis l'API Win32.
La plupart du code spécifique à Win32 signalera les erreurs via $^E. Appels ANSI C et de type Unix
définissez "errno" et ainsi la plupart des codes Perl portables signaleront les erreurs via $!.

Mises en garde mentionnées dans la description de $! s'appliquent généralement également à $^E.

Cette variable a été ajoutée dans Perl 5.003.

Mnémonique : explication supplémentaire de l'erreur.

$EXCEPTIONS_BEING_CAUGHT
$^S État actuel de l'interpréteur.

$^S État
--------- ----------------------------------------------------
undef Module d'analyse, évaluation ou programme principal
true (1) Exécution d'une évaluation
faux (0) Sinon

Le premier état peut se produire dans les gestionnaires $SIG{__DIE__} et $SIG{__WARN__}.

Le nom anglais $EXCEPTIONS_BEING_CAUGHT est légèrement trompeur, car le
La valeur "undef" n'indique pas si des exceptions sont interceptées, car
la compilation du programme principal ne détecte pas les exceptions.

Cette variable a été ajoutée dans Perl 5.004.

$AVERTISSEMENT
$^W La valeur actuelle du commutateur d'avertissement, initialement vraie si -w a été utilisé, faux
sinon, mais directement modifiable.

Voir aussi les avertissements.

Mnémonique : lié au -w interrupteur.

${^WARNING_BITS}
L'ensemble actuel de contrôles d'avertissement activés par le pragma « utiliser les avertissements ». Il a
la même portée que les variables $^H et "%^H". Les valeurs exactes sont considérées
interne au pragma des avertissements et peut changer entre les versions de Perl.

Cette variable a été ajoutée dans Perl v5.6.0.

$OS_ERROR
$ERRNO
$! Lorsqu'il est référencé, $! récupère la valeur actuelle de la variable entière C "errno".
Si $! se voit attribuer une valeur numérique, cette valeur est stockée dans "errno". Quand
référencé sous forme de chaîne, $! renvoie la chaîne d'erreur système correspondant à
"erreur".

De nombreux appels système ou bibliothèque définissent "errno" s'ils échouent, pour indiquer la cause du problème.
échec. Ils font habituellement pas mettez "errno" à zéro s'ils réussissent. Cela signifie
"errno", donc $!, n'a de sens que immédiatement après l'entraînement échec:

if (ouvre mon $fh, "<", $filename) {
# Ici $! n'a aucun sens.
...
}
else {
# SEULEMENT voici $ ! significatif.
...
# Déjà là $ ! pourrait être dénué de sens.
}
# Puisqu'ici nous pouvons avoir soit le succès, soit l'échec,
#$ ! n'a aucun sens.

Ici, dénué de sens ça veut dire que $! peut être sans rapport avec le résultat de "open()"
opérateur. Affectation à $! est tout aussi éphémère. Il peut être utilisé immédiatement
avant d'invoquer l'opérateur "die()", pour définir la valeur de sortie ou pour inspecter le
chaîne d'erreur système correspondant à l'erreur n, ou pour restaurer $! à un sens
Etat.

Mnémonique : Qu'est-ce qui s'est passé ?

%OS_ERROR
%ERREUR
% ! Chaque élément de "%!" a une vraie valeur seulement si $! est défini sur cette valeur. Pour
Par exemple, $!{ENOENT} est vrai si et seulement si la valeur actuelle de $! est "ÉNOENT" ;
c'est-à-dire, si l'erreur la plus récente était "Aucun fichier ou répertoire de ce type" (ou sa morale
équivalent : tous les systèmes d'exploitation ne donnent pas cette erreur exacte, et certainement pas tous
langues). La valeur réelle spécifique n'est pas garantie, mais dans le passé elle a été
généralement la valeur numérique de $!. Pour vérifier si une clé particulière est
significatif sur votre système, utilisez "exists $!{the_key}" ; pour une liste de clés légales, utilisez
"clés %!". Voir Errno pour plus d'informations, et voir également "$!".

Cette variable a été ajoutée dans Perl 5.005.

$CHILD_ERROR
$? L'état renvoyé par la dernière commande de fermeture de tube, backtick ("``"), réussie
appel à "wait()" ou "waitpid()", ou depuis l'opérateur "system()". C'est juste
le mot d'état de 16 bits renvoyé par l'appel système Unix traditionnel "wait()" (ou
le reste est maquillé pour y ressembler). Ainsi, la valeur de sortie du sous-processus est
vraiment ("$? >> 8"), et "$? & 127" donne quel signal, le cas échéant, le processus est mort
from, et "$? & 128" indique s'il y a eu un core dump.

De plus, si la variable "h_errno" est prise en charge en C, sa valeur est renvoyée
par $? si une fonction "gethost*()" échoue.

Si vous avez installé un gestionnaire de signal pour « SIGCHLD », la valeur de $ ? sera généralement
avoir tort en dehors de ce gestionnaire.

À l'intérieur d'un sous-programme "END" $ ? contient la valeur qui va être donnée à
"sortie()". Vous pouvez modifier $? dans un sous-programme "END" pour modifier l'état de sortie de
votre programme. Par exemple:

FINIR {
$? = 1 si $ ? == 255 ; # mourir ferait 255
}

Sous VMS, le pragma « utiliser vmsish 'status' » fait $ ? refléter la sortie réelle du VMS
status, au lieu de l'émulation par défaut du statut POSIX ; voir « $ ? » en perlvms pour
détails.

Mnémonique : similaire à sh et ksh.

$EVAL_ERROR
$@ Le message d'erreur de syntaxe Perl du dernier opérateur "eval()". Si $@ est nul
chaîne, le dernier "eval()" analysé et exécuté correctement (bien que les opérations
vous avez invoqué peut-être échoué de façon normale).

Les messages d'avertissement ne sont pas collectés dans cette variable. Vous pouvez cependant mettre en place un
routine pour traiter les avertissements en définissant $SIG{__WARN__} comme décrit dans "%SIG".

Mnémonique : Où se trouvait l'erreur de syntaxe « à » ?

Variables en relation à le interprète Etat
Ces variables fournissent des informations sur l'état actuel de l'interpréteur.

$COMPILATION
$^C La valeur actuelle de l'indicateur associé au -c changer. Principalement à utiliser avec
-MO=... pour permettre au code de modifier son comportement lors de sa compilation, comme pour
exemple à "AUTOLOAD" au moment de la compilation plutôt qu'un chargement normal et différé.
Définir "$^C = 1" est similaire à appeler "B::minus_c".

Cette variable a été ajoutée dans Perl v5.6.0.

$ DÉBOGAGE
$^D La valeur actuelle des indicateurs de débogage. Peut être lu ou défini. Comme son commandement-
ligne équivalente, vous pouvez utiliser des valeurs numériques ou symboliques, par exemple "$^D = 10" ou "$^D =
"St"".

Mnémonique : valeur de -D interrupteur.

${^ENCODAGE}
DÉCONSEILLÉ !!!

L'exposition objet référence à l'objet "Encode" utilisé pour convertir la source
coder en Unicode. Grâce à cette variable, votre script Perl n'a pas besoin d'être
écrit en UTF-8. La valeur par défaut est "undef".

Définir cette variable sur une valeur autre que "undef" est obsolète en raison de
défauts fondamentaux dans sa conception et sa mise en œuvre. Il est prévu de le supprimer
à partir d'une future version de Perl. Son but était de permettre à vos scripts Perl non-ASCII
ne pas avoir à être écrit en UTF-8 ; c'était utile avant les éditeurs qui travaillaient sur
Les textes codés en UTF-8 étaient courants, mais c'était il y a longtemps. Cela pose des problèmes, comme
comme affectant le fonctionnement d'autres modules qui ne s'y attendent pas, provoquant
chaos général. Son utilisation peut conduire à des erreurs de segmentation.

Si vous avez besoin de quelque chose comme cette fonctionnalité, vous devez utiliser le pragma d'encodage,
qui est également obsolète, mais a moins d’effets secondaires désagréables.

Si vous venez ici parce que votre code est affecté par
Si quelqu'un utilise cette variable, vous pouvez généralement contourner ce problème en procédant comme suit :

local ${^ENCODING} ;

vers le début des fonctions qui sont cassées. Cela indéfinit le
variable pendant la portée de l’exécution de la fonction incluse.

Cette variable a été ajoutée dans Perl 5.8.2.

${^GLOBAL_PHASE}
La phase actuelle de l'interpréteur Perl.

Les valeurs possibles sont :

CONSTRUCTION
Le "PerlInterpreter*" est en cours de construction via "perl_construct". Ce
la valeur est principalement là par souci d'exhaustivité et pour être utilisée via le C sous-jacent
variable "PL_phase". Il n'est pas vraiment possible que le code Perl soit
exécuté à moins que la construction de l’interprète ne soit terminée.

START C'est le moment de la compilation globale. Cela inclut, fondamentalement, chaque "BEGIN"
bloc exécuté directement ou indirectement pendant la compilation du
programme de haut niveau.

Cette phase n'est pas appelée "BEGIN" pour éviter toute confusion avec les blocs "BEGIN",
car ceux-ci sont exécutés pendant la compilation de n'importe quelle unité de compilation, pas
juste le programme de haut niveau. Un nouveau moment de compilation localisé entré lors de l'exécution.
le temps, par exemple par des constructions comme "eval "use SomeModule"" ne sont pas globales
phases de l'interprète, et ne sont donc pas reflétés par "${^GLOBAL_PHASE}".

CHECK Exécution d'éventuels blocs "CHECK".

INIT Similaire à "CHECK", mais pour les blocs "INIT", pas pour les blocs "CHECK".

RUN Le runtime principal, c'est-à-dire l'exécution de "PL_main_root".

END Exécution d'éventuels blocs "END".

DESTRUCTION
Destruction mondiale.

Notez également qu'il n'y a aucune valeur pour les blocs UNITCHECK. C'est parce que ce sont
exécuté pour chaque unité de compilation individuellement et ne constitue donc pas un
phase d’interprétation.

Tous les programmes ne doivent pas nécessairement passer par chacune des phases possibles, mais la transition
d'une phase à l'autre ne peut se produire que dans l'ordre décrit ci-dessus
liste.

Un exemple de toutes les phases que le code Perl peut voir :

BEGIN { print "au moment de la compilation : ${^GLOBAL_PHASE}\n" }

INIT { print "heure d'initialisation : ${^GLOBAL_PHASE}\n" }

CHECK { print "heure de contrôle : ${^GLOBAL_PHASE}\n" }

{
package Imprimer::Phase;

sous nouveau {
mon ($classe, $time) = @_;
return bénit \$time, $class;
}

sous-DÉTRUIRE {
mon $self = shift;
print "$$self : ${^GLOBAL_PHASE}\n" ;
}
}

print "exécution : ${^GLOBAL_PHASE}\n" ;

mon $runtime = Print::Phase->new(
"Les variables lexicales sont récupérées avant la fin"
);

END { print "heure de fin : ${^GLOBAL_PHASE}\n" }

notre $destruct = Print::Phase->new(
"Les variables du package sont récupérées après la FIN"
);

Cela s'imprimera

moment de la compilation : START
heure de contrôle : VÉRIFIER
heure d'initialisation : INIT
exécution : RUN
les variables lexicales sont récupérées avant END : RUN
heure de fin : FIN
les variables du package sont récupérées après END : DESTRUCT

Cette variable a été ajoutée dans Perl 5.14.0.

$^H AVERTISSEMENT : cette variable est strictement destinée à un usage interne uniquement. Sa disponibilité,
le comportement et le contenu sont sujets à changement sans préavis.

Cette variable contient des astuces de compilation pour l'interpréteur Perl. Au bout du
compilation d'un BLOC la valeur de cette variable est restituée à la valeur lors de
l'interpréteur a commencé à compiler le BLOC.

Lorsque Perl commence à analyser toute construction de bloc fournissant une portée lexicale (par exemple,
corps d'évaluation, fichier requis, corps de sous-programme, corps de boucle ou bloc conditionnel), le
la valeur existante de $^H est enregistrée, mais sa valeur reste inchangée. Quand le
la compilation du bloc est terminée, il retrouve la valeur sauvegardée. Entre le
points où sa valeur est enregistrée et restaurée, code qui s'exécute dans BEGIN
Blocks est libre de modifier la valeur de $^H.

Ce comportement fournit la sémantique de la portée lexicale et est utilisé, par exemple, dans
par exemple, le pragma « utiliser strict ».

Le contenu doit être un entier ; différents morceaux sont utilisés pour différents
drapeaux pragmatiques. Voici un exemple :

sous add_100 { $^H |= 0x100 }

sous foo {
DÉBUT { add_100() }
bar->baz($aubaine);
}

Considérez ce qui se passe lors de l'exécution du bloc BEGIN. À ce stade, le
Le bloc BEGIN a déjà été compilé, mais le corps de "foo()" est toujours en cours de compilation.
compilé. La nouvelle valeur de $^H ne sera donc visible que pendant que le corps de
"foo()" est en cours de compilation.

Substitution du bloc "BEGIN { add_100() }" par :

DÉBUT { require strict ; strict->import('vars') }

montre comment "use strict 'vars'" est implémenté. Voici une version conditionnelle
du même pragma lexical :

COMMENCER {
exiger strict; strict->import('vars') si $condition
}

Cette variable a été ajoutée dans Perl 5.003.

%^H Le hachage "%^H" fournit la même sémantique de portée que $^H. Cela le rend utile
pour la mise en œuvre de pragmas à portée lexicale. Voir perlpragma. Toutes les entrées
sont stringifiés lors de l'accès au moment de l'exécution, de sorte que seules les valeurs simples peuvent être
hébergé. Cela signifie pas de pointeurs vers des objets, par exemple.

Lorsque vous placez des éléments dans "%^H", afin d'éviter tout conflit avec d'autres utilisateurs de
le hachage, il existe une convention concernant les clés à utiliser. Un module doit utiliser
uniquement les clés commençant par le nom du module (le nom de son package principal) et un
"/" personnage. Par exemple, un module "Foo::Bar" doit utiliser des clés telles que
"Foo :: Bar/baz".

Cette variable a été ajoutée dans Perl v5.6.0.

${^OUVERT}
Une variable interne utilisée par PerlIO. Une chaîne en deux parties, séparées par un "\0"
octet, la première partie décrit les couches d'entrée, la deuxième partie décrit les
couches de sortie.

Cette variable a été ajoutée dans Perl v5.8.0.

$PERLDB
$^P La variable interne pour la prise en charge du débogage. Les significations des différents bits sont
sous réserve de changement, mais indique actuellement :

0x01 Entrée/sortie du sous-programme de débogage.

0x02 Débogage ligne par ligne. Provoque l'appel du sous-programme "DB::DB()" pour chaque
déclaration exécutée. Provoque également la sauvegarde des lignes de code source (comme 0x400).

0x04 Désactiver les optimisations.

0x08 Conserver davantage de données pour les futures inspections interactives.

0x10 Conserve les informations sur les lignes source sur lesquelles un sous-programme est défini.

0x20 Démarrer en une seule étape.

0x40 Utiliser l'adresse du sous-programme au lieu du nom lors du rapport.

0x80 Signale également "goto &subroutine".

0x100 Fournit des noms de « fichiers » informatifs pour les évaluations en fonction de l'endroit où elles se trouvent
compilé.

0x200 Fournit des noms informatifs aux sous-programmes anonymes en fonction de l'endroit où ils
ont été compilés.

0x400 Enregistrez les lignes de code source dans "@{"_<$filename"}".

0x800 Lors de l'enregistrement de la source, incluez les évaluations qui ne génèrent aucun sous-programme.

MONITORING
Lors de l'enregistrement de la source, incluez la source qui n'a pas été compilée.

Certains bits peuvent être pertinents uniquement au moment de la compilation, d'autres uniquement au moment de l'exécution. C'est un
nouveau mécanisme et les détails peuvent changer. Voir aussi perldebguts.

${^TAINT}
Indique si le mode Taint est activé ou désactivé. 1 pour on (le programme a été exécuté avec -T), 0
pour off, -1 lorsque seuls les avertissements de contamination sont activés (c'est-à-dire avec -t or -TU).

Cette variable est en lecture seule.

Cette variable a été ajoutée dans Perl v5.8.0.

${^UNICODE}
Reflète certains paramètres Unicode de Perl. Voir la documentation Perlrun pour le "-C"
pour plus d’informations sur les valeurs possibles.

Cette variable est définie lors du démarrage de Perl et est ensuite en lecture seule.

Cette variable a été ajoutée dans Perl v5.8.2.

${^UTF8CACHE}
Cette variable contrôle l'état du code de mise en cache de décalage UTF-8 interne. 1 pour
on (valeur par défaut), 0 pour off, -1 pour déboguer le code de mise en cache en vérifiant tous ses
résultats contre les analyses linéaires et paniquer en cas de divergence.

Cette variable a été ajoutée dans Perl v5.8.9. Il est susceptible d'être modifié ou supprimé
sans préavis, mais est actuellement utilisé pour éviter de recalculer les limites de
caractères codés UTF-8 multi-octets.

${^UTF8LOCALE}
Cette variable indique si une locale UTF-8 a été détectée par Perl au démarrage.
Ces informations sont utilisées par Perl lorsqu'il est en mode ajuster-utf8ness-to-locale (comme
lorsqu'il est exécuté avec le commutateur de ligne de commande "-CL"); voir perlrun pour plus d'informations à ce sujet.

Cette variable a été ajoutée dans Perl v5.8.8.

Obsolète et enlevé les variables
La dépréciation d'une variable annonce l'intention des responsables de Perl de supprimer éventuellement
la variable de la langue. Il se peut qu'il soit toujours disponible malgré son statut. Utilisant un
une variable obsolète déclenche un avertissement.

Une fois qu'une variable est supprimée, son utilisation déclenche une erreur vous indiquant que la variable est
non pris en charge.

Voir perldiag pour plus de détails sur les messages d'erreur.

$# $# était une variable qui pouvait être utilisée pour formater des nombres imprimés. Après un
cycle de dépréciation, sa magie a été supprimée dans Perl v5.10.0 et son utilisation déclenche désormais
un avertissement : "$# n'est plus pris en charge".

Ce n'est pas le sceau que vous utilisez devant un nom de tableau pour obtenir le dernier index,
comme $#tableau. C'est toujours ainsi que vous obtenez le dernier index d'un tableau en Perl. Le
les deux n'ont rien à voir l'un avec l'autre.

Obsolète en Perl 5.

Supprimé dans Perl v5.10.0.

$* $* était une variable que vous pouviez utiliser pour activer la correspondance multiligne. Après un
cycle de dépréciation, sa magie a été supprimée dans Perl v5.10.0. Son utilisation déclenche désormais un
avertissement : "$* n'est plus pris en charge". Vous devez utiliser les expressions rationnelles "/s" et "/m"
modificateurs à la place.

Obsolète en Perl 5.

Supprimé dans Perl v5.10.0.

$[ Cette variable stocke l'index du premier élément d'un tableau et du premier
caractère dans une sous-chaîne. La valeur par défaut est 0, mais vous pouvez théoriquement la définir sur
1 pour que Perl se comporte davantage comme awk (ou Fortran) lors de la souscription et lorsque
évaluer le indice() et substr () fonctions.

Depuis la version 5 de Perl, l'affectation à $[ est traitée comme une directive du compilateur, et
ne peut pas influencer le comportement d’un autre fichier. (C'est pourquoi vous ne pouvez attribuer que
constantes de compilation.) Son utilisation est fortement déconseillée.

Avant Perl v5.10.0, l'affectation à $[ pouvait être vue à partir des portées lexicales externes dans
le même fichier, contrairement aux autres directives de compilation (telles que strict). En utilisant
locale() dessus lierait sa valeur strictement à un bloc lexical. Maintenant, c'est toujours
portée lexicale.

Depuis Perl v5.16.0, il est implémenté par le module arybase. Voir arybase pour en savoir plus
détails sur son comportement.

Sous "utiliser la version 5.16" ou "pas de fonctionnalité "array_base"", $[ n'a plus aucun effet, et
contient toujours 0. Lui attribuer 0 est autorisé, mais toute autre valeur sera
produire une erreur.

Mnémonique : [ commence les indices.

Obsolète dans Perl v5.12.0.

Utilisez Perlvar en ligne en utilisant les services onworks.net