perlvar - Online na nuvem

PROGRAMA:

NOME

perlvar - variáveis ​​predefinidas Perl

DESCRIÇÃO

A Sintaxe of Variável Names
Os nomes de variáveis ​​em Perl podem ter vários formatos. Normalmente, eles devem começar com uma letra
ou sublinhado, caso em que podem ser arbitrariamente longos (até um limite interno de 251
caracteres) e pode conter letras, dígitos, sublinhados ou a sequência especial "::" ou
"'". Neste caso, a parte antes do último "::" ou "'" é considerada como um pacote
qualificador; veja perlmod.

Nomes de variáveis ​​Perl também podem ser uma sequência de dígitos ou uma única pontuação ou controle
caractere (com a forma de caractere de controle literal obsoleta). Esses nomes são todos
reservado para usos especiais por Perl; por exemplo, os nomes de todos os dígitos são usados ​​para armazenar dados
capturado por referências anteriores após uma correspondência de expressão regular. Perl tem uma sintaxe especial
para os nomes de caracteres de controle único: entende "^ X" (circunflexo "X") como significando o
control- caractere "X". Por exemplo, a notação $ ^ W (circunflexo de cifrão "W") é o
variável escalar cujo nome é o controle de caractere único - "W". Isto é melhor do que
digitando um controle literal - "W" em seu programa.

Desde Perl v5.6.0, nomes de variáveis ​​Perl podem ser strings alfanuméricas que começam com um acento circunflexo
(ou um caractere de controle, mas este formulário está obsoleto). Essas variáveis ​​devem ser escritas em
o formulário "$ {^ Foo}"; as chaves não são opcionais. "$ {^ Foo}" denota a variável escalar
cujo nome é um controle- "F" seguido por dois "o" 's. Essas variáveis ​​são reservadas para
futuros usos especiais do Perl, exceto para aqueles que começam com "^ _" (controle-sublinhado
ou acento circunflexo). Nenhum nome de caractere de controle que comece com "^ _" adquirirá um
significado especial em qualquer versão futura do Perl; tais nomes podem, portanto, ser usados ​​com segurança em
programas. $ ^ _ em si, no entanto, is reservado.

Identificadores Perl que começam com dígitos, caracteres de controle ou caracteres de pontuação são
isentos dos efeitos da declaração de "pacote" e são sempre obrigados a estar em
pacote "principal"; eles também estão isentos de erros "estritos 'vars'". Alguns outros nomes são
também isento destas maneiras:

ENV STDIN
INC STDOUT
ARGV STDERR
ARGVOUT
SIG

Em particular, as variáveis ​​especiais "$ {^ _ XYZ}" são sempre consideradas como estando no pacote "principal",
independentemente de quaisquer declarações de "pacote" atualmente no escopo.

SPECIAL VARIÁVEIS

Os nomes a seguir têm um significado especial para Perl. A maioria dos nomes de pontuação tem razoável
mnemônicos, ou análogos nas conchas. No entanto, se você deseja usar a variável longa
nomes, você só precisa dizer:

use inglês;

no topo do seu programa. Isso transforma todos os nomes curtos em nomes longos no
pacote atual. Alguns até têm nomes médios, geralmente emprestados de awk. Para mais
informações, consulte o inglês.

Antes de continuar, observe a ordem de classificação das variáveis. Em geral, primeiro listamos o
variáveis ​​em ordem quase lexigráfica que não diferencia maiúsculas de minúsculas (ignorando o "{" ou "^"
palavras anteriores, como em "$ {^ UNICODE}" ou $ ^ T), embora $ _ e @_ movam para cima do
pilha. Para variáveis ​​com o mesmo identificador, listamos em ordem escalar, array, hash,
e bareword.

Geral Variáveis
$ ARG
$ _ A entrada padrão e o espaço de pesquisa de padrões. Os seguintes pares são
equivalente:

while (<>) {...} # equivalente apenas em while!
enquanto (definido ($ _ = <>)) {...}

/ ^ Assunto: /
$ _ = ~ / ^ Assunto: /

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

chomp
chomp ($ _)

Aqui estão os lugares onde Perl assumirá $ _ mesmo se você não o usar:

· As seguintes funções usam $ _ como argumento padrão:

abs, alarme, chomp, chop, chr, chroot, cos, definido, eval, evalbytes, exp, fc,
glob, hex, int, lc, lcfirst, comprimento, log, lstat, mkdir, oct, ord, pos, print,
printf, quotemeta, readlink, readpipe, ref, require, reverse (em contexto escalar
apenas), rmdir, digamos, sin, split (para seu segundo argumento), sqrt, stat, study, uc,
primeiro, desvincular, desempacotar.

· Todos os testes de arquivo ("-f", "-d"), exceto para "-t", cujo padrão é STDIN. Veja "-X"
em perlfunc

· As operações de correspondência de padrões "m //", "s ///" e "tr ///" (também conhecidas como "y ///") quando
usado sem um operador "= ~".

· A variável iteradora padrão em um loop "foreach" se nenhuma outra variável for
fornecido.

· A variável iteradora implícita nas funções "grep ()" e "map ()".

· A variável implícita de "given ()".

· O local padrão para colocar o próximo valor ou registro de entrada quando um " ",
O resultado de "readline", "readdir" ou "cada" operação é testado por si só como o
único critério de um teste "while". Fora de um teste "enquanto", isso não
acontecer.

$ _ é por padrão uma variável global. No entanto, a partir do perl v5.10.0, você pode usar um
versão lexical de $ _ declarando-o em um arquivo ou em um bloco com "meu".
Além disso, declarar "nosso $ _" restaura o $ _ global no escopo atual. No entanto
isso parecia uma boa ideia na época em que foi introduzido, léxico $ _ na verdade
causa mais problemas do que resolve. Se você chamar uma função que espera ser
passou informações via $ _, pode ou não funcionar, dependendo de como a função
está escrito, não havendo nenhuma maneira fácil de resolver isso. Apenas evite $ _ léxico,
a menos que você esteja se sentindo particularmente masoquista. Por esta razão léxico $ _ é
ainda experimental e produzirá um aviso, a menos que os avisos tenham sido desativados.
Tal como acontece com outras características experimentais, o comportamento do léxico $ _ está sujeito a
mudar sem aviso prévio, incluindo a mudança para um erro fatal.

Mnemônico: sublinhado é entendido em certas operações.

@ARG
@_ Dentro de uma sub-rotina, a matriz @_ contém os parâmetros passados ​​para aquele
sub-rotina. Dentro de uma sub-rotina, @_ é a matriz padrão para os operadores de matriz
"pop" e "shift".

Veja perlsub.

$ LIST_SEPARATOR
$ "Quando uma matriz ou uma fatia da matriz é interpolada em uma string entre aspas duplas ou um
contexto semelhante, como "/.../", seus elementos são separados por este valor.
O padrão é um espaço. Por exemplo, este:

print "O array é: @array \ n";

é equivalente a isto:

print "A matriz é:". join ($ ", @array)." \ n ";

Mnemônico: funciona em contexto de aspas duplas.

$ PROCESS_ID
$ PID
$$ O número do processo do Perl executando este script. Embora você pode definir isso
variável, fazer isso geralmente é desencorajado, embora possa ser inestimável para
alguns propósitos de teste. Ele será redefinido automaticamente nas chamadas "fork ()".

Nota para usuários Linux e Debian GNU / kFreeBSD: Antes do Perl v5.16.0, o perl iria
emular a semântica POSIX em sistemas Linux usando LinuxThreads, um
implementação de POSIX Threads que foi substituída pelo POSIX nativo
Biblioteca de Tópicos (NPTL).

LinuxThreads agora está obsoleto no Linux, e o armazenamento em cache "getpid ()" como este fez
incorporar perl desnecessariamente complexo (já que você teria que atualizar manualmente o
valor de $$), então agora $$ e "getppid ()" sempre retornarão os mesmos valores que o
biblioteca C subjacente.

Os sistemas Debian GNU / kFreeBSD também usavam LinuxThreads até e incluindo o 6.0
lançamento, mas depois mudou para a semântica de thread do FreeBSD, que é semelhante ao POSIX.

Para ver se o seu sistema é afetado por esta discrepância, verifique se "getconf
GNU_LIBPTHREAD_VERSION | grep -q NPTL "retorna um valor falso. Threads NTPL
preservar a semântica POSIX.

Mnemônico: igual a conchas.

$ PROGRAM_NAME
$ 0 Contém o nome do programa que está sendo executado.

Em alguns (mas não todos) sistemas operacionais, a atribuição de $ 0 modifica a área de argumento
que o programa "ps" vê. Em algumas plataformas, pode ser necessário usar "ps" especial
opções ou um "ps" diferente para ver as alterações. Modificar o $ 0 é mais útil
como uma forma de indicar o estado atual do programa do que para ocultar o programa
você está correndo.

Observe que existem limitações específicas da plataforma quanto ao comprimento máximo de $ 0. Dentro
o caso mais extremo pode ser limitado ao espaço ocupado pelo $ 0 original.

Em algumas plataformas, pode haver uma quantidade arbitrária de preenchimento, por exemplo, espaço
caracteres, após o nome modificado conforme mostrado por "ps". Em algumas plataformas,
o preenchimento pode se estender até o comprimento original da área do argumento, não
importa o que você faz (este é o caso, por exemplo, do Linux 2.2).

Nota para usuários BSD: definir $ 0 não remove completamente "perl" do ps(1)
saída. Por exemplo, definir $ 0 como "foobar" pode resultar em "perl: foobar (perl)"
(se o prefixo "perl:" e o sufixo "(perl)" são mostrados depende de
sua variante e versão exata do BSD). Este é um recurso do sistema operacional, Perl
não consigo evitar.

Em scripts multithread, Perl coordena as threads de forma que qualquer thread pode
modifique sua cópia do $ 0 e a mudança se tornará visível para ps(1) (assumindo o
o sistema operacional é reproduzido). Observe que a visão de $ 0 que os outros tópicos têm
não mudará, pois eles têm suas próprias cópias.

Se o programa foi fornecido para perl através das opções "-e" ou "-E", $ 0 irá
contém a string "-e".

No Linux a partir de perl v5.14.0, o nome do processo legado será definido com prctl(2), em
além de alterar o nome POSIX via "argv [0]" como perl tem feito desde a versão
4.000. Agora, utilitários de sistema que lêem o nome do processo legado, como ps, top e
killall reconhecerá o nome que você definiu ao atribuir a $ 0. A corda você
o fornecimento será cortado em 16 bytes, esta é uma limitação imposta pelo Linux.

Mnemônico: igual a sh e ksh.

$ REAL_GROUP_ID
$ GID
$ (O verdadeiro gid deste processo. Se você estiver em uma máquina que ofereça suporte para associação em
vários grupos simultaneamente, fornece uma lista separada por espaços dos grupos em que você está.
O primeiro número é aquele retornado por "getgid ()", e os subsequentes por
"getgroups ()", um dos quais pode ser igual ao primeiro número.

No entanto, um valor atribuído a $ (deve ser um único número usado para definir o gid real.
Portanto, o valor dado por $ (deveria não ser atribuído de volta a $ (sem ser forçado
numérico, como adicionando zero. Observe que isso é diferente do gid efetivo
($)) que leva uma lista.

Você pode alterar o gid real e o gid efetivo ao mesmo tempo usando
"POSIX :: setgid ()". Mudanças em $ (requer um cheque em $! Para detectar qualquer possível
erros após uma tentativa de alteração.

Mnemônico: parênteses são usados ​​para grupo coisas. O verdadeiro gid é o grupo que você
esquerda, se você estiver executando setgid.

$ EFFECTIVE_GROUP_ID
$ EGID
$) O gid efetivo deste processo. Se você estiver em uma máquina que suporta
associação em vários grupos simultaneamente, dá uma lista separada por espaço de
grupos em que você está. O primeiro número é aquele retornado por "getegid ()", e o
os subsequentes por "getgroups ()", um dos quais pode ser o mesmo que o primeiro
número.

Da mesma forma, um valor atribuído a $) também deve ser uma lista de números separados por espaço.
O primeiro número define o gid efetivo, e o resto (se houver) é passado para
"setgroups ()". Para obter o efeito de uma lista vazia para "setgroups ()", basta repetir
o novo gid efetivo; ou seja, para forçar um gid efetivo de 5 e um efetivo
lista "setgroups ()" vazia, diga "$) =" 5 5 "".

Você pode alterar o gid efetivo e o gid real ao mesmo tempo usando
"POSIX :: setgid ()" (use apenas um único argumento numérico). Mudanças em $) requerem um
verifique para $! para detectar quaisquer erros possíveis após uma tentativa de alteração.

$ <, $>, $ (e $) podem ser definidos apenas em máquinas que suportam o correspondente
definir [re] [ug] id () rotina. $ (e $) podem ser trocados apenas em máquinas que suportam
"setregid ()".

Mnemônico: parênteses são usados ​​para grupo coisas. O gid efetivo é o grupo
certo para você, se estiver executando setgid.

$ REAL_USER_ID
$ UID
$ <O verdadeiro uid deste processo. Você pode mudar o uid real e o efetivo
uid ao mesmo tempo usando "POSIX :: setuid ()". Uma vez que as alterações em $ <requerem um
chamada de sistema, verifique $! após uma alteração, tente detectar quaisquer erros possíveis.

Mnemônico: é o uid que você veio da, se você estiver executando setuid.

$ EFFECTIVE_USER_ID
$ EUID
$> O uid efetivo deste processo. Por exemplo:

$ <= $>; # definir uid real para efetivo
($ <, $>) = ($>, $ <); # troca uids reais e eficazes

Você pode alterar o uid efetivo e o uid real ao mesmo tempo usando
"POSIX :: setuid ()". Alterações em $> exigem um cheque em $! para detectar qualquer possível
erros após uma tentativa de alteração.

$ <e $> podem ser trocados apenas em máquinas que suportem "setreuid ()".

Mnemônico: é o uid que você foi para, se você estiver executando setuid.

$ SUBSCRIPT_SEPARATOR
$ SUBSEP
$; O separador de subscrito para emulação de array multidimensional. Se você se referir a um
elemento hash como

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

isso realmente significa

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

Mas não coloque

@foo {$ x, $ y, $ z} # uma fatia - observe o @

que significa

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

O padrão é "\ 034", o mesmo que SUBSEP em awk. Se suas chaves contiverem dados binários
pode não haver nenhum valor seguro para $ ;.

Considere o uso de matrizes multidimensionais "reais", conforme descrito em perllol.

Mnemônico: a vírgula (o separador de subscrito sintático) é um ponto e vírgula.

$a
$ b Variáveis ​​de pacote especiais ao usar "sort ()", veja "sort" em perlfunc. Por causa de
essas especialidades $ a e $ b não precisam ser declaradas (usando "use vars", ou
"our ()") mesmo ao usar o pragma "strict 'vars'". Não lexicalize-os com
"meu $ a" ou "meu $ b" se quiser poder usá-los na comparação "sort ()"
bloco ou função.

% ENV O hash% ENV contém seu ambiente atual. Definir um valor em "ENV" muda
o ambiente para qualquer processo filho que você "fork ()" subseqüentemente.

A partir da v5.18.0, tanto as chaves quanto os valores armazenados em% ENV são transformados em string.

meu $ foo = 1;
$ ENV {'bar'} = \ $ foo;
if (ref $ ENV {'bar'}) {
diga "Comportamento anterior a 5.18.0";
Else {}
diga "Comportamento pós-5.18.0";
}

Anteriormente, apenas os processos filhos recebiam valores restritos:

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

# Sempre impresso 'non ref'
sistema ($ ^ X, '-e',
q / print (ref $ ENV {'bar'}? 'ref': 'non ref') /);

Isso acontece porque você não pode realmente compartilhar estruturas de dados arbitrárias com
processos.

$ OLD_PERL_VERSION
$] A revisão, versão e subversão do interpretador Perl, representado como um
decimal da forma 5.XXXYYY, onde XXX é a versão / 1e3 e YYY é a
subversion / 1e6. Por exemplo, Perl v5.10.1 seria "5.010001".

Esta variável pode ser usada para determinar se o interpretador Perl executando um
o script está no intervalo certo de versões:

avisar "Sem PerlIO! \ n" if $] lt '5.008';

Ao comparar $], os operadores de comparação de strings são altamente Recomenda. O
limitações inerentes à representação de ponto flutuante binário às vezes pode levar a
comparações incorretas para alguns números em algumas arquiteturas.

Veja também a documentação de "usar a VERSÃO" e "exigir a VERSÃO" para um conveniente
maneira de falhar se o interpretador Perl em execução for muito antigo.

Veja "$ ^ V" para uma representação da versão Perl como um objeto de versão, que
permite comparações de strings mais flexíveis.

A principal vantagem de $] sobre $ ^ V é que funciona da mesma forma em qualquer versão do
Perl. As desvantagens são que não pode ser facilmente comparado a versões em outros
formatos (por exemplo, v-strings literais, "v1.2.3" ou objetos de versão) e numéricos
as comparações podem falhar ocasionalmente; é bom para verificações de versão literal de string e
ruim para comparar a uma variável que não foi verificada de sanidade.

O formulário $ OLD_PERL_VERSION foi adicionado ao Perl v5.20.0 por razões históricas, mas
seu uso é desencorajado. (Se a sua razão para usar $] é executar código em perls antigos, então
referir-se a ele como $ OLD_PERL_VERSION seria contraproducente.)

Mnemônico: Esta versão do perl está no colchete direito?

$ SYSTEM_FD_MAX
$ ^ F O descritor de arquivo de sistema máximo, normalmente 2. Os descritores de arquivo de sistema são
passado para processos "exec ()" ed, enquanto descritores de arquivo superiores não são. Além disso,
durante um "open ()", os descritores de arquivo do sistema são preservados mesmo se o "open ()"
falha (os descritores de arquivo comuns são fechados antes que "open ()" seja tentado).
O status close-on-exec de um descritor de arquivo será decidido de acordo com o
valor de $ ^ F quando o arquivo, canal ou socket correspondente foi aberto, não a hora
do "exec ()".

@F O array @F contém os campos de cada linha lida quando o modo de divisão automática é
ligadas. Veja perlrun para o -a chave. Esta matriz é específica do pacote e
deve ser declarado ou dado um nome de pacote completo se não estiver no pacote principal ao ser executado
sob "estrito 'vars'".

@INC O array @INC contém a lista de locais que "fazem EXPR", "requerem" ou "usam"
construções procuram seus arquivos de biblioteca. Inicialmente consiste nos argumentos
para qualquer -I opções de linha de comando, seguidas pela biblioteca Perl padrão, provavelmente
/ usr / local / lib / perl, seguido por ".", para representar o diretório atual. ("."
não será anexado se as verificações de contaminação estiverem habilitadas, seja por "-T" ou por "-t".) Se
você precisa modificar isso em tempo de execução, você deve usar o pragma "use lib" para obter o
biblioteca dependente da máquina carregada adequadamente também:

use lib '/ mypath / libdir /';
use SomeMod;

Você também pode inserir ganchos no sistema de inclusão de arquivos, colocando o código Perl
diretamente em @INC. Esses ganchos podem ser referências de sub-rotina, referências de array ou
objetos abençoados. Veja "requer" em perlfunc para detalhes.

% INC O hash% INC contém entradas para cada nome de arquivo incluído por meio de "do", "require",
ou operadores de "uso". A chaveéo nome do arquivo que você especificou (com os nomes dos módulos
convertido em nomes de caminho), e o valor é a localização do arquivo encontrado. O
operador "require" usa esse hash para determinar se um arquivo específico tem
já foi incluído.

Se o arquivo foi carregado por meio de um gancho (por exemplo, uma referência de sub-rotina, consulte "require" em
perlfunc para uma descrição desses ganchos), este gancho é, por padrão, inserido em
% INC no lugar de um nome de arquivo. Observe, no entanto, que o gancho pode ter definido o% INC
entrada por si só para fornecer algumas informações mais específicas.

$ INPLACE_EDIT
$ ^ I O valor atual da extensão inplace-edit. Use "undef" para desativar o local
edição.

Mnemônico: valor de -i interruptor.

$ ^ M Por padrão, ficar sem memória é um erro fatal que não pode ser rastreado. No entanto, se
devidamente construído, Perl pode usar o conteúdo de $ ^ M como um pool de memória de emergência após
"morrer ()" ing. Suponha que seu Perl tenha sido compilado com "-DPERL_EMERGENCY_SBRK" e
usado o malloc do Perl. Então

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

alocaria um buffer de 64 K para uso em uma emergência. Veja o INSTALAR arquivo no
Distribuição Perl para obter informações sobre como adicionar sinalizadores de compilação C personalizados quando
compilando perl. Para desencorajar o uso casual deste recurso avançado, não há
Nome longo em inglês para esta variável.

Esta variável foi adicionada no Perl 5.004.

$ OSNAME
$ ^ O O nome do sistema operacional sob o qual esta cópia do Perl foi construída, como
determinado durante o processo de configuração. Para exemplos, consulte "PLATAFORMAS" em
perlport.

O valor é idêntico a $ Config {'osname'}. Veja também Config e o -V comando-
mudança de linha documentada em perlrun.

Em plataformas Windows, $ ^ O não é muito útil: uma vez que é sempre "MSWin32", ele
não diz a diferença entre 95/98 / ME / NT / 2000 / XP / CE / .NET. Usar
"Win32 :: GetOSName ()" ou Win32 :: GetOSVersion () (veja Win32 e perlport) para
distinguir entre as variantes.

Esta variável foi adicionada no Perl 5.003.

% SIG O hash% SIG contém manipuladores de sinal para sinais. Por exemplo:

sub handler {# 1º argumento é o nome do sinal
meu ($ sig) = @_;
print "Detectou uma assinatura SIG $ - desligando \ n";
fechar (LOG);
saída(0);
}

$ SIG {'INT'} = \ & handler;
$ SIG {'QUIT'} = \ & handler;
...
$ SIG {'INT'} = 'PADRÃO'; # restaurar ação padrão
$ SIG {'SAIR'} = 'IGNORAR'; # ignorar SIGQUIT

Usar um valor de 'IGNORE' geralmente tem o efeito de ignorar o sinal, exceto
para o sinal "CHLD". Veja perlipc para mais informações sobre este caso especial.

Aqui estão alguns outros exemplos:

$ SIG {"PIPE"} = "Encanador"; # assume main :: Encanador (não
# recomendado)
$ SIG {"TUBO"} = \ & Encanador; # bem; assumir atual
# Encanador
$ SIG {"PIPE"} = * Encanador; # um tanto esotérico
$ SIG {"TUBO"} = Encanador (); # opa, o que encanador ()
# Retorna??

Certifique-se de não usar uma palavra de barra como o nome de um manipulador de sinal, para que você não
inadvertidamente chamá-lo.

Se o seu sistema tem a função "sigaction ()", então os manipuladores de sinal estão instalados
usando isso. Isso significa que você obtém um tratamento de sinal confiável.

A política de entrega padrão de sinais mudou no Perl v5.8.0 de imediato (também
conhecido como "inseguro") para diferido, também conhecido como "sinais seguros". Veja perlipc para
Mais Informações.

Certos ganchos internos também podem ser definidos usando o hash% SIG. A rotina indicada
por $ SIG {__ WARN__} é chamado quando uma mensagem de aviso está prestes a ser impressa. O
mensagem de aviso é passada como o primeiro argumento. A presença de um "__WARN__"
gancho faz com que a impressão normal de avisos para "STDERR" seja suprimida. Você
pode usar isso para salvar avisos em uma variável ou transformar avisos em erros fatais,
como isso:

local $ SIG {__ WARN__} = sub {dado $ _ [0]};
eval $ proggie;

Como o gancho 'IGNORE' não é compatível com "__WARN__", você pode desativar os avisos
usando a sub-rotina vazia:

local $ SIG {__ WARN__} = sub {};

A rotina indicada por $ SIG {__ DIE__} é chamada quando se trata de uma exceção fatal
para ser jogado. A mensagem de erro é passada como primeiro argumento. Quando um
A rotina de gancho "__DIE__" retorna, o processamento da exceção continua como deveria
na ausência do gancho, a menos que a própria rotina de gancho saia por meio de um "goto
& sub ", uma saída de loop ou um" die () ". O manipulador" __DIE__ "está explicitamente desabilitado
durante a chamada, para que você possa morrer de um manipulador "__DIE__". Da mesma forma para
"__AVISAR__".

Devido a uma falha de implementação, o gancho $ SIG {__ DIE__} é chamado mesmo dentro de um
"eval ()". Não use isso para reescrever uma exceção pendente em $ @, ou como uma bizarra
substitua a substituição de "CORE :: GLOBAL :: die ()". Esta ação estranha em um
distância pode ser fixada em uma versão futura de modo que $ SIG {__ DIE__} só seja chamado se
seu programa está prestes a ser encerrado, como era a intenção original. Qualquer outro uso é
descontinuada.

Os manipuladores "__DIE __" / "__ WARN__" são muito especiais em um aspecto: eles podem ser chamados
para relatar (prováveis) erros encontrados pelo analisador. Nesse caso, o analisador pode ser
em estado inconsistente, portanto, qualquer tentativa de avaliar o código Perl de tal manipulador
provavelmente resultará em um segfault. Isso significa que os avisos ou erros que
O resultado da análise de Perl deve ser usado com extremo cuidado, como este:

requer carpa se definido $ ^ S;
Carp :: confess ("Algo errado") se definido & Carp :: confess;
morrer "Algo errado, mas não foi possível carregar a carpa para dar"
. "backtrace ... \ n \ t"
. "Para ver o backtrace, tente iniciar o Perl com a opção -MCarp";

Aqui, a primeira linha irá carregar "Carp" a menos que é o analisador que chamou o
manipulador. A segunda linha imprimirá um backtrace e morrerá se "Carp" estiver disponível.
A terceira linha será executada apenas se "Carp" não estiver disponível.

Ter que pensar sobre a variável $ ^ S em seus manipuladores de exceção é simplesmente
errado. $ SIG {__ DIE__}, conforme implementado atualmente, convida a graves e difíceis de
rastrear erros. Evite-o e use um "END {}" ou CORE :: GLOBAL :: override do dado
ao invés.

Veja "die" em perlfunc, "warn" em perlfunc, "eval" em perlfunc e avisos para
informações adicionais.

$ BASETIME
$ ^ T A hora em que o programa começou a ser executado, em segundos desde a época (início
de 1970). Os valores retornados pelo -M, -A e -C filetests baseiam-se nisto
valor.

$ PERL_VERSION
$ ^ V A revisão, versão e subversão do interpretador Perl, representado como um
objeto de versão.

Esta variável apareceu pela primeira vez em perl v5.6.0; versões anteriores do perl verão um
valor indefinido. Antes do perl v5.10.0 $ ^ V era representado como uma string em vez de
do que um objeto de versão.

$ ^ V pode ser usado para determinar se o interpretador Perl executando um script está em
a gama certa de versões. Por exemplo:

avisar "Hashes não aleatórios! \ n" if! $ ^ V ou $ ^ V lt v5.8.1

Enquanto os objetos de versão sobrecarregam a stringificação, para converter $ ^ V portavelmente em seu
representação de string, use a conversão "% vd" de "sprintf ()", que funciona para ambos
V-strings ou objetos de versão:

printf "versão é v% vd \ n", $ ^ V; # Versão do Perl

Veja a documentação de "usar VERSÃO" e "exigir VERSÃO" para uma maneira conveniente
falhar se o interpretador Perl em execução for muito antigo.

Veja também $] para uma representação decimal da versão Perl.

A principal vantagem de $ ^ V sobre $] é que, para Perl v5.10.0 ou posterior, ele sobrecarrega
operadores, permitindo fácil comparação com outras representações de versão (por exemplo
decimal, string v literal, "v1.2.3" ou objetos). A desvantagem é que antes
a v5.10.0, era apenas uma string v literal, que não pode ser impressa facilmente ou
comparados.

Mnemônico: use ^ V para um objeto de versão.

$ {^ WIN32_SLOPPY_STAT}
Se esta variável for definida com um valor verdadeiro, então "stat ()" no Windows não tentará
abra o arquivo. Isso significa que a contagem de links não pode ser determinada e o arquivo
os atributos podem estar desatualizados se houver hardlinks adicionais para o arquivo. No
por outro lado, não abrir o arquivo é consideravelmente mais rápido, especialmente para arquivos em
unidades de rede.

Esta variável pode ser definida no sitecustomize.pl arquivo para configurar o local
Instalação do Perl para usar "desleixado" "stat ()" por padrão. Veja a documentação para
-f em perlrun para obter mais informações sobre a personalização do site.

Esta variável foi adicionada no Perl v5.10.0.

$ EXECUTABLE_NAME
$ ^ X O nome usado para executar a cópia atual do Perl, do "argv [0]" do C ou (onde
suportado) / proc / self / exe.

Dependendo do sistema operacional do host, o valor de $ ^ X pode ser relativo ou
nome do caminho absoluto do arquivo de programa perl, ou pode ser a string usada para invocar
perl, mas não o nome do caminho do arquivo de programa perl. Além disso, a maioria dos sistemas operacionais
permite invocar programas que não estão na variável de ambiente PATH, portanto,
não há garantia de que o valor de $ ^ X esteja em PATH. Para VMS, o valor pode ou pode
não inclui um número de versão.

Você geralmente pode usar o valor de $ ^ X para invocar novamente uma cópia independente do mesmo
perl que está em execução, por exemplo,

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

Mas lembre-se de que nem todos os sistemas operacionais suportam bifurcação ou captura do
saída de comandos, portanto, esta instrução complexa pode não ser portátil.

Não é seguro usar o valor de $ ^ X como o nome do caminho de um arquivo, pois alguns
sistemas que têm um sufixo obrigatório em arquivos executáveis ​​não requerem o uso do
sufixo ao invocar um comando. Para converter o valor de $ ^ X em um nome de caminho, use
as seguintes afirmações:

# Construa um conjunto de nomes de arquivo (não nomes de comando).
usar configuração;
meu $ this_perl = $ ^ X;
if ($ ^ O ne 'VMS') {
$ this_perl. = $ Config {_exe}
a menos que $ this_perl = ~ m / $ Config {_exe} $ / i;
}

Porque muitos sistemas operacionais permitem que qualquer pessoa com acesso de leitura ao programa Perl
arquivo para fazer uma cópia dele, corrigir a cópia e, em seguida, executar a cópia, o
o programador Perl preocupado com a segurança deve tomar cuidado para invocar a cópia instalada
de perl, não a cópia referenciada por $ ^ X. As seguintes afirmações realizam isso
objetivo, e produzir um caminho que pode ser invocado como um comando ou referenciado como um
arquivo.

usar configuração;
meu $ secure_perl_path = $ Config {perlpath};
if ($ ^ O ne 'VMS') {
$ secure_perl_path. = $ Config {_exe}
a menos que $ secure_perl_path = ~ m / $ Config {_exe} $ / i;
}

Variáveis relacionado para regular expressões
A maioria das variáveis ​​especiais relacionadas às expressões regulares são efeitos colaterais. Conjuntos Perl
essas variáveis ​​quando houver uma correspondência bem-sucedida, então você deve verificar o resultado da correspondência
antes de usá-los. Por exemplo:

if (/ P (A) TT (ER) N /) {
print "Encontrei $ 1 e $ 2 \ n";
}

Essas variáveis ​​são somente leitura e com escopo dinâmico, a menos que observemos o contrário.

A natureza dinâmica das variáveis ​​de expressão regular significa que seu valor é limitado
ao bloco em que estão, conforme demonstrado por este trecho de código:

meu $ outer = 'Wallace e Grommit';
meu $ inner = 'Mutt e Jeff';

meu $ pattern = qr / (\ S +) e (\ S +) /;

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

{
EXTERIOR:
show_n () se $ outer = ~ m / $ padrão /;

INTERNO: {
show_n () se $ inner = ~ m / $ pattern /;
}

mostrando();
}

A saída mostra que, enquanto no bloco "OUTER", os valores de $ 1 e $ 2 são do
coincidir com $ outer. Dentro do bloco "INNER", os valores de $ 1 e $ 2 são do
corresponder a $ inner, mas apenas até o final do bloco (ou seja, o escopo dinâmico). Depois de
o bloco "INNER" é concluído, os valores de $ 1 e $ 2 voltam aos valores da correspondência
contra $ outer, embora não tenhamos feito outra correspondência:

$ 1 é Wallace; $ 2 é Grommit
$ 1 é Mutt; $ 2 é Jeff
$ 1 é Wallace; $ 2 é Grommit

Desempenho questões

Tradicionalmente em Perl, qualquer uso de qualquer uma das três variáveis ​​"$` ", $ & ou" $ '"(ou seus
equivalentes de "usar inglês") em qualquer lugar do código, causou todos os padrões subsequentes de sucesso
corresponde para fazer uma cópia da string correspondida, no caso de o código poder acessar posteriormente
uma dessas variáveis. Isso impôs uma penalidade de desempenho considerável em todo o
programa, então geralmente o uso dessas variáveis ​​tem sido desencorajado.

No Perl 5.6.0 foram introduzidos os arrays dinâmicos "@ -" e "@ +" que fornecem os índices de
partidas bem-sucedidas. Então, você pode, por exemplo, fazer isso:

$ str = ~ / padrão /;

imprimir $ `, $ &, $ '; # ruim: hit de desempenho

imprimir # bom: sem sucesso de desempenho
substr ($ str, 0, $ - [0]),
substr ($ str, $ - [0], $ + [0] - $ - [0]),
substr ($ str, $ + [0]);

Em Perl 5.10.0, o sinalizador de operador de correspondência "/ p" e "$ {^ PREMATCH}", "$ {^ MATCH}" e
Foram introduzidas variáveis ​​"$ {^ POSTMATCH}", que permitiam que você sofresse apenas as penalidades
em padrões marcados com "/ p".

Em Perl 5.18.0 em diante, perl começou a notar a presença de cada uma das três variáveis
separadamente, e copiei apenas a parte necessária da string; tão em

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

perl copiaria apenas a parte "abcd" da string. Isso pode fazer uma grande diferença em
algo como

$ str = 'x' x 1_000_000;
$ &; # ops
$ str = ~ / x / g # um caractere copiado um milhão de vezes, não um milhão de caracteres

No Perl 5.20.0, um novo sistema copy-on-write foi habilitado por padrão, o que finalmente corrige todos
problemas de desempenho com essas três variáveis ​​e os torna seguros para uso em qualquer lugar.

Os módulos "Devel :: NYTProf" e "Devel :: FindAmpersand" podem ajudá-lo a encontrar os usos desses
variáveis ​​de correspondência problemáticas em seu código.

$<dígitos> ($ 1, $ 2, ...)
Contém o subpadrão do conjunto correspondente de captura de parênteses de
a última correspondência de padrão bem-sucedida, sem contar os padrões combinados em blocos aninhados
que já foram encerrados.

Essas variáveis ​​são somente leitura e com escopo dinâmico.

Mnemônico: como \ dígitos.

$ MATCH
$ & A string correspondida pela última correspondência de padrão com sucesso (sem contar quaisquer correspondências
oculto dentro de um BLOCO ou "eval ()" incluído no BLOCO atual).

Consulte "Problemas de desempenho" acima para as sérias implicações de desempenho do uso
esta variável (mesmo uma vez) em seu código.

Esta variável é somente leitura e com escopo dinâmico.

Mnemônico: como "&" em alguns editores.

$ {^ MATCH}
Isso é semelhante a $ & ($ MATCH), exceto que não incorre no desempenho
penalidade associada a essa variável.

Consulte "Problemas de desempenho" acima.

No Perl v5.18 e anteriores, só é garantido o retorno de um valor definido quando
o padrão foi compilado ou executado com o modificador "/ p". No Perl v5.20, o
O modificador "/ p" não faz nada, então "$ {^ MATCH}" faz a mesma coisa que $ MATCH.

Esta variável foi adicionada no Perl v5.10.0.

Esta variável é somente leitura e com escopo dinâmico.

$ PREMATCH
$ `A string anterior foi correspondida pela última correspondência de padrão bem-sucedida,
sem contar quaisquer correspondências escondidas dentro de um BLOCO ou "eval" incluído pelo atual
BLOQUEAR.

Consulte "Problemas de desempenho" acima para as sérias implicações de desempenho do uso
esta variável (mesmo uma vez) em seu código.

Esta variável é somente leitura e com escopo dinâmico.

Mnemônico: "` "geralmente precede uma string entre aspas.

$ {^ PREMATCH}
Isso é semelhante a "$` "($ PREMATCH), exceto que não incorre no desempenho
penalidade associada a essa variável.

Consulte "Problemas de desempenho" acima.

No Perl v5.18 e anteriores, só é garantido o retorno de um valor definido quando
o padrão foi compilado ou executado com o modificador "/ p". No Perl v5.20, o
O modificador "/ p" não faz nada, então "$ {^ PREMATCH}" faz a mesma coisa que $ PREMATCH.

Esta variável foi adicionada no Perl v5.10.0.

Esta variável é somente leitura e com escopo dinâmico.

$ POSTMATCH
$ 'A string a seguir a tudo o que foi correspondido pela última correspondência de padrão bem-sucedida
(sem contar as correspondências ocultas dentro de um BLOCO ou "eval ()" entre o
BLOCO atual). Exemplo:

local $ _ = 'abcdefghi';
/ def /;
imprimir "$`: $ &: $ '\ n "; # imprime abc: def: ghi

Consulte "Problemas de desempenho" acima para as sérias implicações de desempenho do uso
esta variável (mesmo uma vez) em seu código.

Esta variável é somente leitura e com escopo dinâmico.

Mnemônico: "'" geralmente segue uma string entre aspas.

$ {^ POSTMATCH}
Isso é semelhante a "$ '" ($ POSTMATCH), exceto que não incorre no desempenho
penalidade associada a essa variável.

Consulte "Problemas de desempenho" acima.

No Perl v5.18 e anteriores, só é garantido o retorno de um valor definido quando
o padrão foi compilado ou executado com o modificador "/ p". No Perl v5.20, o
O modificador "/ p" não faz nada, então "$ {^ POSTMATCH}" faz a mesma coisa que $ POSTMATCH.

Esta variável foi adicionada no Perl v5.10.0.

Esta variável é somente leitura e com escopo dinâmico.

$ LAST_PAREN_MATCH
$ + O texto correspondido pelo último colchete do último padrão de pesquisa bem-sucedido. Isto
é útil se você não sabe qual de um conjunto de padrões alternativos corresponde.
Por exemplo:

/ Versão: (. *) | Revisão: (. *) / && ($ rev = $ +);

Esta variável é somente leitura e com escopo dinâmico.

Mnemônico: seja positivo e voltado para o futuro.

$ LAST_SUBMATCH_RESULT
$ ^ N O texto correspondido pelo grupo usado mais recentemente fechado (ou seja, o grupo com o
parêntese de fechamento mais à direita) do último padrão de pesquisa bem-sucedido.

Isso é usado principalmente dentro de blocos "(? {...})" para examinar texto recentemente
coincide. Por exemplo, para capturar efetivamente o texto para uma variável (além de
$ 1, $ 2, etc.), substitua "(...)" por

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

Ao definir e usar $ var desta forma, você não precisa se preocupar com
exatamente qual conjunto numerado de parênteses eles são.

Esta variável foi adicionada no Perl v5.8.0.

Mnemônico: o (possivelmente) parêntese aninhado que fechou mais recentemente.

@LAST_MATCH_END
@ + Este array contém os deslocamentos das extremidades dos últimos submatches bem-sucedidos no
escopo dinâmico atualmente ativo. $ + [0] é o deslocamento na string do final de
a partida inteira. Este é o mesmo valor que a função "pos" retorna quando
chamado na variável que foi comparada. O no elemento desta matriz
mantém o deslocamento do nth submatch, então $ + [1] é o deslocamento após onde $ 1 termina,
$ + [2] o deslocamento após onde termina $ 2 e assim por diante. Você pode usar $ # + para determinar como
muitos subgrupos estavam na última partida bem-sucedida. Veja os exemplos dados para o
"@-" variável.

Esta variável foi adicionada no Perl v5.6.0.

% LAST_PAREN_MATCH
% + Semelhante a "@ +", o hash "% +" permite o acesso aos buffers de captura nomeados, deve
eles existem, na última correspondência bem-sucedida no escopo dinâmico atualmente ativo.

Por exemplo, $ + {foo} é equivalente a $ 1 após a seguinte correspondência:

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

As chaves da lista de hash "% +" apenas os nomes dos buffers que foram capturados (e
que estão assim associados a valores definidos).

O comportamento subjacente de "% +" é fornecido pelo Tie :: Hash :: NamedCapture
módulo.

Nota: "% -" e "% +" são visualizações vinculadas em um hash interno comum associado ao
última expressão regular bem-sucedida. Portanto, combinar o acesso iterativo a eles via
"cada" pode ter resultados imprevisíveis. Da mesma forma, se a última correspondência bem-sucedida
mudanças, então os resultados podem ser surpreendentes.

Esta variável foi adicionada no Perl v5.10.0.

Esta variável é somente leitura e com escopo dinâmico.

@LAST_MATCH_START
@ - "$ - [0]" é o deslocamento do início da última partida bem-sucedida. "$ - ["n"]" é o
deslocamento do início da substring correspondido por n-ésimo subpadrão, ou undef se o
subpadrão não corresponde.

Assim, após uma correspondência contra $ _, $ & coincide com "substr $ _, $ - [0], $ + [0] -
$ - [0] ". Da mesma forma, $n coincide com "substr $ _, $ - [n], $ + [n] - $ - [n]" se "$ - [n]"
é definido e $ + coincide com "substr $ _, $ - [$ # -], $ + [$ # -] - $ - [$ # -]". Um
pode usar "$ # -" para encontrar o último subgrupo correspondido na última correspondência bem-sucedida.
Compare com $ # +, o número de subgrupos na expressão regular. Comparar
com "@ +".

Esta matriz contém os deslocamentos do início das últimas sub-partidas bem-sucedidas
no escopo dinâmico atualmente ativo. "$ - [0]" é o deslocamento na string de
o início de toda a partida. O no elemento desta matriz mantém o deslocamento
que acontecerá no marco da nº submatch, então "$ - [1]" é o deslocamento onde $ 1 começa, "$ - [2]" o deslocamento
onde $ 2 começa e assim por diante.

Após uma comparação com alguma variável $ var:

"$` "é igual a" substr ($ var, 0, $ - [0]) "
$ & é igual a "substr ($ var, $ - [0], $ + [0] - $ - [0])"
"$ '" é o mesmo que "substr ($ var, $ + [0])"
$ 1 é igual a "substr ($ var, $ - [1], $ + [1] - $ - [1])"
$ 2 é igual a "substr ($ var, $ - [2], $ + [2] - $ - [2])"
$ 3 é igual a "substr ($ var, $ - [3], $ + [3] - $ - [3])"

Esta variável foi adicionada no Perl v5.6.0.

% LAST_MATCH_START
% - Semelhante a "% +", esta variável permite o acesso aos grupos de captura nomeados no
última correspondência bem-sucedida no escopo dinâmico atualmente ativo. Para cada captura
nome do grupo encontrado na expressão regular, associa uma referência a uma matriz
contendo a lista de valores capturados por todos os buffers com aquele nome (deve haver
ser vários deles), na ordem em que aparecem.

Aqui está um exemplo:

if ('1234' = ~ / (? 1) (? 2) (? 3) (? 4) /) {
foreach meu $ bufname (chaves de classificação% -) {
meu $ ary = $ - {$ bufname};
foreach my $ idx (0 .. $ # $ ary) {
imprimir "\ $ - {$ bufname} [$ idx]:",
(definido ($ ary -> [$ idx])
? "'$ ary -> [$ idx]'"
: "undef"),
"\ n";
}
}
}

imprimiria:

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

As chaves do hash "% -" correspondem a todos os nomes de buffer encontrados no
expressão.

O comportamento de "% -" é implementado por meio do módulo Tie :: Hash :: NamedCapture.

Nota: "% -" e "% +" são visualizações vinculadas em um hash interno comum associado ao
última expressão regular bem-sucedida. Portanto, combinar o acesso iterativo a eles via
"cada" pode ter resultados imprevisíveis. Da mesma forma, se a última correspondência bem-sucedida
mudanças, então os resultados podem ser surpreendentes.

Esta variável foi adicionada no Perl v5.10.0.

Esta variável é somente leitura e com escopo dinâmico.

$ LAST_REGEXP_CODE_RESULT
$ ^ R O resultado da avaliação da última expressão regular "(? {Code})" bem-sucedida
afirmação (ver perlre). Pode ser escrito para.

Esta variável foi adicionada no Perl 5.005.

$ {^ RE_DEBUG_FLAGS}
O valor atual dos sinalizadores de depuração regex. Definido como 0 para nenhuma saída de depuração mesmo
quando o módulo "re 'debug'" é carregado. Veja re para detalhes.

Esta variável foi adicionada no Perl v5.10.0.

$ {^ RE_TRIE_MAXBUF}
Controla como certas otimizações de regex são aplicadas e quanta memória elas
utilizar. Este valor por padrão é 65536 que corresponde a 512kB temporário
cache. Defina para um valor mais alto para trocar memória por velocidade ao combinar grande
alternações. Defina-o com um valor mais baixo se quiser que as otimizações sejam tão
conservador da memória possível, mas ainda ocorre, e defina-o com um valor negativo
para evitar a otimização e conservar o máximo de memória. Em situações normais
esta variável não deve ser do seu interesse.

Esta variável foi adicionada no Perl v5.10.0.

Variáveis relacionado para manipuladores de arquivo
Variáveis ​​que dependem do filehandle atualmente selecionado podem ser definidas chamando um
método de objeto apropriado no objeto "IO :: Handle", embora seja menos eficiente do que
usando as variáveis ​​internas regulares. (As linhas de resumo abaixo contêm a palavra
HANDLE.) Primeiro você deve dizer

use IO :: Handle;

depois do qual você pode usar qualquer

método HANDLE EXPR

ou com mais segurança,

HANDLE-> método (EXPR)

Cada método retorna o valor antigo do atributo "IO :: Handle". Cada método leva um
EXPR opcional, que, se fornecido, especifica o novo valor para o atributo "IO :: Handle"
em questão. Se não for fornecido, a maioria dos métodos não faz nada para o valor atual - exceto para
"autoflush ()", que assumirá 1 para você, só para ser diferente.

Porque o carregamento na classe "IO :: Handle" é uma operação cara, você deve aprender como
para usar as variáveis ​​internas regulares.

Algumas dessas variáveis ​​são consideradas "somente leitura". Isso significa que se você tentar atribuir
a esta variável, direta ou indiretamente por meio de uma referência, você levantará um run-
exceção de tempo.

Você deve ter muito cuidado ao modificar os valores padrão da maioria das variáveis ​​especiais
descrito neste documento. Na maioria dos casos, você deseja localizar essas variáveis ​​antes
alterá-los, pois se não o fizer, a mudança pode afetar outros módulos que dependem do
valores padrão das variáveis ​​especiais que você alterou. Este é um dos corretos
maneiras de ler todo o arquivo de uma vez:

abra meu $ fh, "<", "foo" ou morra $ !;
local $ /; # ativar o modo slurp localizado
meu $ content = <$ fh>;
fechar $ fh;

Mas o código a seguir é muito ruim:

abra meu $ fh, "<", "foo" ou morra $ !;
undef $ /; # ativar o modo slurp
meu $ content = <$ fh>;
fechar $ fh;

já que algum outro módulo, pode querer ler dados de algum arquivo no "modo de linha" padrão,
então, se o código que acabamos de apresentar foi executado, o valor global de $ / é agora
alterado para qualquer outro código em execução no mesmo interpretador Perl.

Normalmente, quando uma variável é localizada, você quer ter certeza de que essa mudança afeta o
menor escopo possível. Então, a menos que você já esteja dentro de algum bloco curto "{}", você
deve criar um você mesmo. Por exemplo:

meu $ content = '';
abra meu $ fh, "<", "foo" ou morra $ !;
{
local $ /;
$ content = <$ fh>;
}
fechar $ fh;

Aqui está um exemplo de como seu próprio código pode quebrar:

para (1..3) {
$ \ = "\ r \ n";
nasty_break ();
imprimir "$ _";
}

sub desagradável_break {
$ \ = "\ f";
# faça algo com $ _
}

Você provavelmente espera que este código imprima o equivalente a

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

mas em vez disso você obtém:

"1 \ f2 \ f3 \ f"

Por quê? Porque "nasty_break ()" modifica "$ \" sem localizá-lo primeiro. O valor que você definiu
em "nasty_break ()" ainda está lá quando você retornar. A correção é adicionar "local ()" para que o
valor não vaza de "nasty_break ()":

local $ \ = "\ f";

É fácil perceber o problema em um exemplo tão curto, mas em um código mais complicado você
estão procurando problemas se você não localizar as alterações nas variáveis ​​especiais.

$ ARGV Contém o nome do arquivo atual ao ler de "<>".

@ARGV O array @ARGV contém os argumentos da linha de comando destinados ao script.
$ # ARGV é geralmente o número de argumentos menos um, porque $ ARGV [0] é o
primeiro argumento, não o próprio nome do comando do programa. Veja "$ 0" para o comando
nome.

ARGV O identificador de arquivo especial que itera sobre nomes de arquivo de linha de comando em @ARGV.
Normalmente escrito como o identificador de arquivo nulo no operador de ângulo "<>". Observe que
atualmente "ARGV" só tem seu efeito mágico dentro do operador "<>"; em outro lugar
é apenas um identificador de arquivo simples correspondente ao último arquivo aberto por "<>". Dentro
particular, passando "\ * ARGV" como um parâmetro para uma função que espera um
filehandle pode não fazer com que sua função leia automaticamente o conteúdo de todos
os arquivos em @ARGV.

ARGVOUT O identificador de arquivo especial que aponta para o arquivo de saída atualmente aberto ao fazer
processamento de edição no local com -i. Útil quando você tem que fazer muitas inserções
e não quero continuar modificando $ _. Veja perlrun para o -i interruptor.

IO :: Handle-> output_field_separator (EXPR)
$ OUTPUT_FIELD_SEPARATOR
$ OFS
$, O separador de campo de saída para o operador de impressão. Se definido, este valor é
impresso entre cada um dos argumentos de impressão. O padrão é "undef".

Você não pode chamar "output_field_separator ()" em um identificador, apenas como um método estático.
Consulte IO :: Handle.

Mnemônico: o que é impresso quando há um "," em seu extrato de impressão.

HANDLE-> input_line_number (EXPR)
$ INPUT_LINE_NUMBER
$ NR
$. Número da linha atual para o último filehandle acessado.

Cada filehandle em Perl conta o número de linhas que foram lidas dele.
(Dependendo do valor de $ /, a ideia de Perl do que constitui uma linha pode não
corresponder ao seu.) Quando uma linha é lida a partir de um filehandle (via "readline ()" ou "<>"),
ou quando "tell ()" ou "seek ()" é chamado, $. torna-se um pseudônimo para a linha
contador para esse filehandle.

Você pode ajustar o contador atribuindo $., Mas isso não irá realmente mover o
ponteiro de busca. Localizando $. precisarão não localizar da filehandle's linha contar.
Em vez disso, ele localizará a noção de perl de qual filehandle $. está atualmente
alias para.

$. é redefinido quando o filehandle é fechado, mas não quando um identificador de arquivo aberto é
reaberto sem um "close ()" intermediário. Para obter mais detalhes, consulte "Operadores de E / S"
em perlop. Porque "<>" nunca faz um fechamento explícito, os números de linha aumentam
em arquivos "ARGV" (mas veja exemplos em "eof" em perlfunc).

Você também pode usar "HANDLE-> input_line_number (EXPR)" para acessar o contador de linha para
um determinado identificador de arquivo sem ter que se preocupar com qual identificador você acessou pela última vez.

Mnemônico: muitos programas usam "." para significar o número da linha atual.

IO :: Handle-> input_record_separator (EXPR)
$ INPUT_RECORD_SEPARATOR
$ RS
$ / O separador de registro de entrada, nova linha por padrão. Isso influencia a ideia de Perl de
o que é uma "linha". Funciona como awkvariável RS de, incluindo o tratamento de linhas vazias como
um terminador se definido como uma string nula (uma linha vazia não pode conter nenhum espaço ou
guias). Você pode configurá-lo para uma string de vários caracteres para corresponder a um
terminator, ou "undef" para ler até o final do arquivo. Configurando para "\ n \ n"
significa algo ligeiramente diferente de definir como "", se o arquivo contiver
linhas vazias consecutivas. Definir como "" tratará dois ou mais vazios consecutivos
linhas como uma única linha vazia. Definir como "\ n \ n" assumirá cegamente que o próximo
o caractere de entrada pertence ao próximo parágrafo, mesmo se for uma nova linha.

local $ /; # ativar o modo "slurp"
local $ _ = ; # arquivo inteiro agora aqui
s / \ n [\ t] + / / g;

Lembre-se: o valor de $ / é uma string, não um regex. awk tem que ser melhor para
algo. :-)

Definir $ / como uma referência a um inteiro, escalar contendo um inteiro ou escalar
que é conversível em um inteiro tentará ler registros em vez de linhas,
com o tamanho máximo do registro sendo o número inteiro referenciado de caracteres.
Então, é isso:

local $ / = \ 32768; # ou \ "32768" ou \ $ var_containing_32768
abra meu $ fh, "<", $ myfile ou morra $ !;
local $ _ = <$ fh>;

irá ler um registro de no máximo 32768 caracteres de $ fh. Se você não é
lendo de um arquivo orientado a registro (ou seu sistema operacional não tem orientado a registro
arquivos), então você provavelmente obterá um bloco completo de dados a cada leitura. Se um registro
for maior do que o tamanho do registro que você definiu, você obterá o registro em pedaços.
Tentar definir o tamanho do registro para zero ou menos está obsoleto e fará com que $ / a
tem o valor de "undef", o que causará leitura no (resto do) todo
arquivo.

A partir de 5.19.9, definir $ / para qualquer outra forma de referência gerará um erro fatal
exceção. Isso é uma preparação para oferecer suporte a novas maneiras de definir $ / no futuro.

Somente no VMS, as leituras de registro contornam as camadas PerlIO e qualquer buffer associado, então
você não deve misturar leituras de registros e não registros no mesmo filehandle. Modo de gravação
mistura com o modo de linha apenas quando a mesma camada de buffer está em uso para ambos os modos.

Você não pode chamar "input_record_separator ()" em um identificador, apenas como um método estático.
Consulte IO :: Handle.

Veja também "Newlines" em perlport. Veja também "$.".

Mnemônico: / delimita os limites das linhas ao citar poesia.

IO :: Handle-> output_record_separator (EXPR)
$ OUTPUT_RECORD_SEPARATOR
$ ORS
$ \ O separador de registro de saída para o operador de impressão. Se definido, este valor é
impresso após o último dos argumentos de impressão. O padrão é "undef".

Você não pode chamar "output_record_separator ()" em um identificador, apenas como um método estático.
Consulte IO :: Handle.

Mnemônico: você define "$ \" em vez de adicionar "\ n" no final da impressão. Além disso, é
assim como $ /, mas é o que você "recebe de volta" do Perl.

HANDLE-> autoflush (EXPR)
$ OUTPUT_AUTOFLUSH
$ | Se definido como diferente de zero, força um flush imediatamente e após cada escrita ou impressão no
canal de saída atualmente selecionado. O padrão é 0 (independentemente de
o canal está realmente armazenado em buffer pelo sistema ou não; $ | diz a você apenas se você
pediu ao Perl explicitamente para liberar após cada gravação). STDOUT normalmente será de linha
buffered se a saída for para o terminal e block buffer caso contrário. Configurando isso
variável é útil principalmente quando você está enviando para um tubo ou tomada, como
quando você está executando um programa Perl sob rsh e quero ver o resultado como é
acontecendo. Isso não tem efeito no buffer de entrada. Veja "getc" em perlfunc para
naquela. Consulte "selecionar" em perlfunc para saber como selecionar o canal de saída. Veja também
IO :: Handle.

Mnemônico: quando você quer que seus canos estejam bem quentes.

$ {^ LAST_FH}
Esta variável somente leitura contém uma referência ao manipulador de arquivos lido pela última vez. Isto é
definido pela " "," readline "," tell "," eof "e" seek ". Este é o mesmo identificador
aquele $. e "tell" e "eof" sem uso de argumentos. É também a alça usada
quando Perl acrescenta ", linha 1 "para uma mensagem de erro ou aviso.

Esta variável foi adicionada no Perl v5.18.0.

Variáveis relacionado para formatos

As variáveis ​​especiais para formatos são um subconjunto daquelas para manipuladores de arquivos. Veja perlform para
mais informações sobre os formatos do Perl.

$ ACCUMULATOR
$ ^ A O valor atual do acumulador "write ()" para linhas "format ()". Um formato
contém chamadas "formline ()" que colocam seu resultado em $ ^ A. Depois de chamar seu
formato, "write ()" imprime o conteúdo de $ ^ A e esvazia. Então você nunca realmente
veja o conteúdo de $ ^ A, a menos que você mesmo chame "formline ()" e olhe para ele.
Veja perlform e "formline PICTURE, LIST" em perlfunc.

IO :: Handle-> format_formfeed (EXPR)
$ FORMAT_FORMFEED
$ ^ L Quais formatos são gerados como um feed de formulário. O padrão é "\ f".

Você não pode chamar "format_formfeed ()" em um identificador, apenas como um método estático. Ver
IO :: Handle.

HANDLE-> format_page_number (EXPR)
$ FORMAT_PAGE_NUMBER
$% O número da página atual do canal de saída atualmente selecionado.

Mnemônico: "%" é o número da página em nroff.

HANDLE-> format_lines_left (EXPR)
$ FORMAT_LINES_LEFT
$ - O número de linhas restantes na página do canal de saída atualmente selecionado.

Mnemônico: lines_on_page - lines_printed.

IO :: Handle-> format_line_break_characters EXPR
$ FORMAT_LINE_BREAK_CHARACTERS
$: O conjunto atual de caracteres após o qual uma string pode ser quebrada para preencher
campos de continuação (começando com "^") em um formato. O padrão é "\ n-", para
quebra em um espaço, nova linha ou hífen.

Você não pode chamar "format_line_break_characters ()" em um identificador, apenas como um estático
método. Consulte IO :: Handle.

Mnemônico: um "dois pontos" na poesia é uma parte de uma linha.

HANDLE-> format_lines_per_page (EXPR)
$ FORMAT_LINES_PER_PAGE
$ = O comprimento da página atual (linhas imprimíveis) da saída atualmente selecionada
canal. O padrão é 60.

Mnemônico: = possui linhas horizontais.

HANDLE-> format_top_name (EXPR)
$ FORMAT_TOP_NAME
$ ^ O nome do formato do topo da página atual para a saída atualmente selecionada
canal. O padrão é o nome do filehandle com "_TOP" anexado. Por
Por exemplo, o nome principal do formato padrão para o identificador de arquivo "STDOUT" é "STDOUT_TOP".

Mnemônico: aponta para o início da página.

HANDLE-> format_name (EXPR)
$ FORMAT_NAME
$ ~ O nome do formato de relatório atual para o canal de saída atualmente selecionado.
O nome do formato padrão é igual ao nome do manipulador de arquivo. Por exemplo, o
O nome do formato padrão para o identificador de arquivo "STDOUT" é apenas "STDOUT".

Mnemônico: irmão de $ ^.

erro Variáveis
As variáveis ​​$ @, $ !, $ ^ E e $? contém informações sobre diferentes tipos de erro
condições que podem aparecer durante a execução de um programa Perl. As variáveis ​​são mostradas
ordenado pela "distância" entre o subsistema que relatou o erro e o Perl
processo. Eles correspondem a erros detectados pelo interpretador Perl, biblioteca C, operando
sistema ou um programa externo, respectivamente.

Para ilustrar as diferenças entre essas variáveis, considere o seguinte Perl
expressão, que usa uma string entre aspas simples. Após a execução desta instrução, perl
pode ter definido todas as quatro variáveis ​​de erro especiais:

eval q {
abra meu $ pipe, "/ cdrom / install |" ou morra $ !;
meu @res = <$ pipe>;
feche $ pipe ou die "bad pipe: $ ?, $!";
};

Quando perl executa a expressão "eval ()", ele traduz a expressão "open ()", " ", e
"feche" as chamadas na biblioteca de tempo de execução C e daí para o kernel do sistema operacional. perl
define $! ao "errno" da biblioteca C se uma dessas chamadas falhar.

$ @ é definido se a string a ser "eval" -ed não compilou (isto pode acontecer se "abrir" ou
"close" foram importados com protótipos ruins), ou se o código Perl foi executado durante a avaliação
"faleceu. Nestes casos, o valor de $ @ é o erro de compilação ou o argumento para "morrer"
(que irá interpolar $! e $?). (Veja também Fatal, no entanto.)

Em alguns sistemas operacionais, $ ^ E pode conter um indicador de erro mais detalhado, como em
neste caso, "bandeja do CD-ROM não fechada." Sistemas que não suportam mensagens de erro estendidas
deixe $ ^ E igual a $ !.

Finalmente, $? pode ser definido para um valor diferente de 0 se o programa externo / cdrom / install falha. O
os oito bits superiores refletem as condições de erro específicas encontradas pelo programa (o
valor "exit ()" do programa). Os oito bits inferiores refletem o modo de falha, como o sinal
morte e informações de despejo de núcleo. Ver esperar(2) para obter detalhes. Em contraste com $! e $ ^ E,
que são definidos apenas se uma condição de erro for detectada, a variável $? é definido em cada "espera"
ou canalize "close", substituindo o valor antigo. É mais parecido com $ @, que em cada "eval ()"
é sempre definido em caso de falha e limpo em caso de sucesso.

Para obter mais detalhes, consulte as descrições individuais em $ @, $ !, $ ^ E e $ ?.

$ {^ CHILD_ERROR_NATIVE}
O status nativo retornado pelo último fechamento do tubo, comando backtick ("` `"),
chamada bem-sucedida para "wait ()" ou "waitpid ()", ou do operador "system ()". Sobre
Sistemas semelhantes a POSIX, este valor pode ser decodificado com WIFEXITED, WEXITSTATUS,
Funções WIFSIGNALED, WTERMSIG, WIFSTOPPED, WSTOPSIG e WIFCONTINUED fornecidas por
o módulo POSIX.

No VMS, isso reflete o status de saída real do VMS; ou seja, é o mesmo que $? quando
o pragma "use vmsish 'status'" está em vigor.

Esta variável foi adicionada no Perl v5.10.0.

$ EXTENDED_OS_ERROR
$ ^ E Informações de erro específicas para o sistema operacional atual. No momento, este
difere de $! sob apenas VMS, OS / 2 e Win32 (e para MacPerl). Em todos os outros
plataformas, $ ^ E é sempre igual a $ !.

No VMS, $ ^ E fornece o valor do status VMS do último erro do sistema. Isto é
informações mais específicas sobre o último erro do sistema do que as fornecidas por $ !.
Isso é particularmente importante quando $! está configurado para EVMSERR.

Em OS / 2, $ ^ E é definido como o código de erro da última chamada à API OS / 2 por meio de
CRT ou diretamente do perl.

No Win32, $ ^ E sempre retorna as últimas informações de erro relatadas pelo Win32
chame "GetLastError ()" que descreve o último erro de dentro da API Win32.
A maioria dos códigos específicos do Win32 relatará erros por meio de $ ^ E. ANSI C e chamadas do tipo Unix
defina "errno" para que a maioria dos códigos Perl portáteis relatem erros via $ !.

Advertências mencionadas na descrição de $! geralmente se aplicam a $ ^ E, também.

Esta variável foi adicionada no Perl 5.003.

Mnemônico: Explicação extra do erro.

$ EXCEPTIONS_BEING_CAUGHT
$ ^ S Estado atual do intérprete.

Estado $ ^ S
----------------------------------------------
Módulo de análise undef, eval ou programa principal
verdadeiro (1) Executando uma avaliação
falso (0) Caso contrário

O primeiro estado pode acontecer nos manipuladores $ SIG {__ DIE__} e $ SIG {__ WARN__}.

O nome em inglês $ EXCEPTIONS_BEING_CAUGHT é um pouco enganador, porque o
O valor "undef" não indica se as exceções estão sendo capturadas, uma vez que
a compilação do programa principal não captura exceções.

Esta variável foi adicionada no Perl 5.004.

$ AVISO
$ ^ W O valor atual da chave de aviso, inicialmente verdadeiro se -w foi usado, falso
caso contrário, mas diretamente modificável.

Veja também avisos.

Mnemônico: relacionado ao -w interruptor.

$ {^ WARNING_BITS}
O conjunto atual de verificações de aviso habilitado pelo pragma "use warnings". Tem
o mesmo escopo das variáveis ​​$ ^ H e "% ^ H". Os valores exatos são considerados
interno ao pragma de avisos e pode mudar entre as versões do Perl.

Esta variável foi adicionada no Perl v5.6.0.

$ OS_ERROR
$ ERRNO
$! Quando referenciado, $! recupera o valor atual da variável inteira C "errno".
Se $! é atribuído um valor numérico, esse valor é armazenado em "errno". Quando
referenciado como uma string, $! produz a string de erro do sistema correspondente a
"errno".

Muitas chamadas de sistema ou biblioteca definem "errno" se falharem, para indicar a causa de
fracasso. Eles geralmente fazem não defina "errno" para zero se eles forem bem-sucedidos. Isso significa
"errno", portanto $ !, é significativo apenas imediatamente depois de um falha:

if (abrir meu $ fh, "<", $ filename) {
# Aqui $! não tem sentido.
...
}
else {
# SÓ aqui está $! significativo.
...
# Já está aqui $! pode não ter sentido.
}
# Uma vez que aqui podemos ter sucesso ou fracasso,
# $! não tem sentido.

Aqui, sem sentido significa que $! pode não estar relacionado ao resultado do "open ()"
operador. Atribuição a $! é igualmente efêmero. Pode ser usado imediatamente
antes de invocar o operador "die ()", para definir o valor de saída ou para inspecionar o
string de erro do sistema correspondente ao erro nou para restaurar $! para um significativo
Estado.

Mnemônico: O que acabou de explodir?

% OS_ERROR
% ERRNO
%! Cada elemento de "%!" tem um valor verdadeiro apenas se $! é definido com esse valor. Por
exemplo, $! {ENOENT} é verdadeiro se e somente se o valor atual de $! é "ENOENT";
isto é, se o erro mais recente foi "Nenhum arquivo ou diretório" (ou sua moral
equivalente: nem todos os sistemas operacionais fornecem esse erro exato e, certamente, nem todos
línguas). O valor verdadeiro específico não é garantido, mas no passado
geralmente é o valor numérico de $ !. Para verificar se uma determinada chave é
significativo em seu sistema, use "existe $! {the_key}"; para obter uma lista de chaves legais, use
"chaves %!". Consulte Errno para obter mais informações e também consulte "$!".

Esta variável foi adicionada no Perl 5.005.

$ CHILD_ERROR
$? O status retornado pelo último fechamento do tubo, comando backtick ("` `"), bem-sucedido
chamada para "wait ()" ou "waitpid ()", ou do operador "system ()". Isso é só
a palavra de status de 16 bits retornada pela chamada de sistema "wait ()" tradicional do Unix (ou
outra coisa é feita para se parecer com ele). Assim, o valor de saída do subprocesso é
realmente ("$? >> 8"), e "$? & 127" dá qual sinal, se houver, o processo morreu
de e "$? & 128" relata se houve um despejo de memória.

Além disso, se a variável "h_errno" for compatível com C, seu valor será retornado
via $? se alguma função "gethost * ()" falhar.

Se você instalou um manipulador de sinal para "SIGCHLD", o valor de $? normalmente
estar errado fora desse manipulador.

Dentro de uma sub-rotina "END" $? contém o valor que será dado a
"saída()". Você pode modificar $? em uma sub-rotina "END" para alterar o status de saída de
seu programa. Por exemplo:

FIM {
$? = 1 se $? == 255; # morrer tornaria 255
}

No VMS, o pragma "use vmsish 'status'" torna $? refletem a saída VMS real
status, em vez da emulação padrão do status POSIX; veja "$?" em perlvms para
Detalhes.

Mnemônico: semelhante a sh e ksh.

$ EVAL_ERROR
$ @ A mensagem de erro de sintaxe Perl do último operador "eval ()". Se $ @ for nulo
string, o último "eval ()" analisado e executado corretamente (embora as operações
que você invocou pode ter falhado da maneira normal).

Mensagens de aviso não são coletadas nesta variável. Você pode, no entanto, configurar um
rotina para processar avisos definindo $ SIG {__ WARN__} conforme descrito em "% SIG".

Mnemônico: Onde estava o erro de sintaxe "at"?

Variáveis relacionado para da intérprete estado
Essas variáveis ​​fornecem informações sobre o estado atual do interpretador.

$ COMPILING
$ ^ C O valor atual do sinalizador associado ao -c chave. Principalmente de uso com
-MO = ... para permitir que o código altere seu comportamento ao ser compilado, como para
exemplo para "AUTOLOAD" em tempo de compilação em vez de carregamento normal adiado.
Definir "$ ^ C = 1" é semelhante a chamar "B :: minus_c".

Esta variável foi adicionada no Perl v5.6.0.

$ DEBUGGING
$ ^ D O valor atual dos sinalizadores de depuração. Pode ser lido ou definido. Como seu comando-
equivalente de linha, você pode usar valores numéricos ou simbólicos, por exemplo, "$ ^ D = 10" ou "$ ^ D =
"st" ".

Mnemônico: valor de -D interruptor.

$ {^ ENCODING}
DESCONTINUADA!!!

A objeto referência para o objeto "Codificar" que é usado para converter a fonte
código para Unicode. Graças a esta variável, seu script Perl não precisa ser
escrito em UTF-8. O padrão é "undef".

Definir esta variável para qualquer outro valor diferente de "undef" está obsoleto devido a
defeitos fundamentais em seu projeto e implementação. Está planejado para removê-lo
de uma versão futura do Perl. Seu objetivo era permitir que seus scripts Perl não ASCII
não ter que ser escrito em UTF-8; isso foi útil antes dos editores que trabalharam em
O texto codificado em UTF-8 era comum, mas isso foi há muito tempo. Isso causa problemas, como
como afetando a operação de outros módulos que não estão esperando por isso, causando
caos geral. Seu uso pode levar a segfaults.

Se você precisa de algo como esta funcionalidade, você deve usar o pragma de codificação,
que também está obsoleto, mas tem menos efeitos colaterais desagradáveis.

Se você está vindo aqui porque o seu código está sendo adversamente afetado por
alguém usar essa variável, geralmente você pode contornar isso fazendo o seguinte:

local $ {^ ENCODING};

perto do início das funções que estão sendo interrompidas. Isso indefiniu o
variável durante o escopo de execução da função de inclusão.

Esta variável foi adicionada no Perl 5.8.2.

$ {^ GLOBAL_PHASE}
A fase atual do interpretador perl.

Os valores possíveis são:

CONSTRUIR
O "PerlInterpreter *" está sendo construído via "perl_construct". Isto
o valor está lá principalmente para integridade e para uso por meio do C subjacente
variável "PL_phase". Não é realmente possível para o código Perl ser
executado a menos que a construção do intérprete seja concluída.

START Este é o tempo de compilação global. Isso inclui, basicamente, todos os "BEGIN"
bloco executado direta ou indiretamente durante o tempo de compilação do
programa de alto nível.

Esta fase não é chamada "BEGIN" para evitar confusão com blocos "BEGIN",
como eles são executados durante o tempo de compilação de qualquer unidade de compilação, não
apenas o programa de nível superior. Um novo tempo de compilação localizado inserido em run-
tempo, por exemplo, por construções como "eval "use SomeModule"" não são globais
fases do interpretador e, portanto, não são refletidas por "${^GLOBAL_PHASE}".

CHECK Execução de qualquer bloco "CHECK".

INIT Semelhante a "CHECK", mas para blocos "INIT", não para blocos "CHECK".

RUN O tempo de execução principal, ou seja, a execução de "PL_main_root".

END Execução de qualquer bloco "END".

DESTRUIR
Destruição mundial.

Observe também que não há valor para blocos UNITCHECK. Isso porque esses são
executado para cada unidade de compilação individualmente e, portanto, não é um
fase do intérprete.

Nem todo programa precisa passar por cada uma das fases possíveis, mas a transição
de uma fase para outra só pode acontecer na ordem descrita acima
Lista.

Um exemplo de todas as fases do código Perl pode ser visto:

BEGIN { print "tempo de compilação: ${^GLOBAL_PHASE}\n" }

INIT { print "init-time: ${^GLOBAL_PHASE}\n" }

CHECK { print "check-time: ${^GLOBAL_PHASE}\n" }

{
impressão do pacote::Fase;

sub-novo {
minha ($classe, $hora) = @_;
retornar bênção \ $ time, $ class;
}

sub DESTRUIR {
meu $ self = shift;
print "$$self: ${^GLOBAL_PHASE}\n";
}
}

print "tempo de execução: ${^GLOBAL_PHASE}\n";

meu $ runtime = Print::Phase->new(
"variáveis ​​léxicas são coletadas como lixo antes de END"
);

END { print "horário de término: ${^GLOBAL_PHASE}\n" }

nosso $destruct = Print::Phase->new(
"variáveis ​​de pacote são coletadas como lixo após END"
);

Isso vai imprimir

tempo de compilação: START
check-time: VERIFICAR
tempo de inicialização: INIT
tempo de execução: RUN
variáveis ​​léxicas são coletadas como lixo antes de END: RUN
hora final: END
variáveis ​​de pacote são coletadas como lixo após END: DESTRUCT

Esta variável foi adicionada no Perl 5.14.0.

$^H AVISO: Esta variável é estritamente para uso interno. A sua disponibilidade,
comportamento e conteúdo estão sujeitos a alterações sem aviso prévio.

Essa variável contém dicas de tempo de compilação para o interpretador Perl. No fim de
compilação de um BLOCO o valor desta variável é restaurado ao valor quando
o interpretador começou a compilar o BLOCO.

Quando o perl começa a analisar qualquer construção de bloco que forneça um escopo lexical (por exemplo,
eval, arquivo necessário, corpo de sub-rotina, corpo de loop ou bloco condicional), o
valor existente de $^H é salvo, mas seu valor permanece inalterado. Quando o
a compilação do bloco for concluída, ele recupera o valor salvo. Entre o
pontos onde seu valor é salvo e restaurado, código que executa dentro de BEGIN
blocks é livre para alterar o valor de $^H.

Esse comportamento fornece a semântica do escopo lexical e é usado em, para
exemplo, o pragma "use strict".

O conteúdo deve ser um número inteiro; pedaços diferentes dele são usados ​​para diferentes
bandeiras pragmáticas. Aqui está um exemplo:

sub add_100 { $^H |= 0x100}

sub foo {
COMECE { add_100() }
bar->baz($boon);
}

Considere o que acontece durante a execução do bloco BEGIN. Neste ponto o
O bloco BEGIN já foi compilado, mas o corpo de "foo()" ainda está sendo
compilado. O novo valor de $^H será, portanto, visível apenas enquanto o corpo de
"foo()" está sendo compilado.

Substituição do bloco "BEGIN { add_100() }" por:

BEGIN { requer estrito; strict->import('vars') }

demonstra como "use strict 'vars'" é implementado. Aqui está uma versão condicional
do mesmo pragma lexical:

INÍCIO {
exigem rigoroso; strict->import('vars') if $condition
}

Esta variável foi adicionada no Perl 5.003.

%^H O hash "%^H" fornece a mesma semântica de escopo que $^H. Isso o torna útil
para implementação de pragmas com escopo lexical. Veja perlpragma. Todas as entradas
são stringificados quando acessados ​​em tempo de execução, portanto, apenas valores simples podem ser
acomodado. Isso significa que não há ponteiros para objetos, por exemplo.

Ao colocar itens em "%^H", para evitar conflitos com outros usuários de
o hash existe uma convenção sobre quais chaves usar. Um módulo deve usar
apenas chaves que começam com o nome do módulo (o nome de seu pacote principal) e um
"/" personagem. Por exemplo, um módulo "Foo::Bar" deve usar chaves como
"Foo::Bar/baz".

Esta variável foi adicionada no Perl v5.6.0.

${^ABRIR}
Uma variável interna usada pelo PerlIO. Uma string em duas partes, separadas por um "\0"
byte, a primeira parte descreve as camadas de entrada, a segunda parte descreve o
camadas de saída.

Esta variável foi adicionada no Perl v5.8.0.

$PERLDB
$^P A variável interna para suporte a depuração. Os significados dos vários bits são
sujeito a alterações, mas atualmente indicam:

0x01 Entrada/saída da sub-rotina de depuração.

0x02 Depuração linha por linha. Faz com que a sub-rotina "DB::DB()" seja chamada para cada
instrução executada. Também faz com que as linhas de código-fonte sejam salvas (como 0x400).

0x04 Desligue as otimizações.

0x08 Preserve mais dados para futuras inspeções interativas.

0x10 Manter informações sobre as linhas de origem nas quais uma sub-rotina está definida.

0x20 Comece com um passo ativado.

0x40 Use o endereço da sub-rotina em vez do nome ao relatar.

0x80 Reporte "goto &sub-rotina" também.

0x100 Fornece nomes de "arquivos" informativos para avaliações com base no local em que foram
compilado.

0x200 Fornece nomes informativos para sub-rotinas anônimas com base no local em que
foram compilados.

0x400 Salvar linhas de código-fonte em "@{"_<$filename"}".

0x800 Ao salvar a fonte, inclua evals que não gerem sub-rotinas.

0x1000
Ao salvar a fonte, inclua a fonte que não foi compilada.

Alguns bits podem ser relevantes apenas em tempo de compilação, alguns apenas em tempo de execução. Isto é um
novo mecanismo e os detalhes podem mudar. Veja também perldebguts.

${^TAINT}
Reflete se o modo de contaminação está ativado ou desativado. 1 para ligado (o programa foi executado com -T), 0
para desligado, -1 quando apenas avisos de contaminação estão habilitados (ou seja, com -t or -TU).

Esta variável é somente leitura.

Esta variável foi adicionada no Perl v5.8.0.

${^UNICODE}
Reflete certas configurações Unicode de Perl. Veja a documentação do perlrun para o "-C"
switch para obter mais informações sobre os valores possíveis.

Essa variável é definida durante a inicialização do Perl e, posteriormente, é somente leitura.

Esta variável foi adicionada no Perl v5.8.2.

${^UTF8CACHE}
Essa variável controla o estado do código de cache de deslocamento UTF-8 interno. 1 para
on (o padrão), 0 para off, -1 para depurar o código de cache verificando todos os seus
resultados contra varreduras lineares e entrar em pânico em qualquer discrepância.

Esta variável foi adicionada em Perl v5.8.9. Está sujeito a alteração ou remoção
sem aviso prévio, mas atualmente é usado para evitar recalcular os limites de
caracteres codificados em UTF-8 de vários bytes.

${^UTF8LOCALE}
Essa variável indica se uma localidade UTF-8 foi detectada pelo perl na inicialização.
Esta informação é usada pelo perl quando está no modo de ajuste utf8ness-to-locale (como
quando executado com a opção de linha de comando "-CL"); veja perlrun para mais informações sobre isso.

Esta variável foi adicionada no Perl v5.8.8.

Obsoleto e afastado variáveis
Descontinuar uma variável anuncia a intenção dos mantenedores do perl de eventualmente remover
a variável do idioma. Ele ainda pode estar disponível, apesar de seu status. Usando um
variável obsoleta aciona um aviso.

Depois que uma variável é removida, seu uso aciona um erro informando que a variável é
sem suporte.

Consulte perldiag para obter detalhes sobre mensagens de erro.

$# $# era uma variável que podia ser usada para formatar números impressos. Após um
ciclo de depreciação, sua mágica foi removida no Perl v5.10.0 e usá-la agora aciona
um aviso: "$# não é mais suportado".

Este não é o sigilo que você usa na frente de um nome de array para obter o último índice,
como $#array. Ainda é assim que você obtém o último índice de um array em Perl. O
dois não têm nada a ver um com o outro.

Obsoleto em Perl 5.

Removido em Perl v5.10.0.

$* $* era uma variável que você poderia usar para habilitar a correspondência de várias linhas. Após um
ciclo de depreciação, sua mágica foi removida no Perl v5.10.0. Usá-lo agora aciona um
aviso: "$* não é mais suportado". Você deve usar a expressão regular "/s" e "/m"
modificadores em vez disso.

Obsoleto em Perl 5.

Removido em Perl v5.10.0.

$[ Esta variável armazena o índice do primeiro elemento em uma matriz e do primeiro
caractere em uma substring. O padrão é 0, mas você poderia, teoricamente, configurá-lo para
1 para fazer Perl se comportar mais como awk (ou Fortran) ao subscrever e quando
avaliando o índice() e substr () funções.

A partir da versão 5 do Perl, a atribuição a $[ é tratada como uma diretiva de compilador e
não pode influenciar o comportamento de nenhum outro arquivo. (É por isso que você só pode atribuir
constantes de tempo de compilação para ele.) Seu uso é altamente desencorajado.

Antes do Perl v5.10.0, a atribuição a $[ podia ser vista de escopos léxicos externos em
o mesmo arquivo, ao contrário de outras diretivas de tempo de compilação (como strict). Usando
local() nele vincularia seu valor estritamente a um bloco lexical. Agora é sempre
lexicalmente delimitado.

A partir do Perl v5.16.0, ele é implementado pelo módulo arybase. Veja arybase para mais
detalhes sobre seu comportamento.

Em "use v5.16" ou "no feature "array_base"", $[ não tem mais nenhum efeito e
sempre contém 0. Atribuir 0 a ele é permitido, mas qualquer outro valor será
produzir um erro.

Mnemônico: [ inicia os subscritos.

Obsoleto em Perl v5.12.0.

Use perlvar online usando serviços onworks.net