r8 - 18 Aug 2009 - RonaldoLima

BUGS
TRADUZINDO

NAME

perlvar - Variáveis especiais do Perl

DESCRIPTION

Nomes especiais

Este documento trata de variáveis que possuem significados especiais para a linguagem Perl. A maioria dos nomes destas variáveis representam razoavelmente bem o seu significado ou possuem significado análogo em algum shell. Mas, se você quiser usar nomes longos de variáveis como sinônimos, basta dizer:

    use English;

no início do seu programa. Isto dá apelidos longos a todos os nomes curtos no pacote corrente. Algumas dessas variáveis possuem até mesmo nomes médios, geralmente vindos do awk. No geral, é melhor usar o

    use English '-no_match_vars';

se você não precisa de $PREMATCH, $MATCH ou $POSTMATCH, uma vez que isso evita uma certa perda de performance no uso de expressões regulares. Veja the English manpage. Variáveis que dependem do filehandle atualmente selecionado podem ser ajustadas para chamar um método objeto apropriado no objeto IO::Handle, ainda que isso seja menos eficiente que usar as variáveis regulares internas. (Linhas resumidas abaixo sobre contêm a palavra HANDLE.) Primeiro você deve dizer:

    use IO::Handle;

depois disso você pode usar ambos

    method HANDLE EXPR

ou mais seguro,

    HANDLE->method(EXPR)

Cada método retorna o valor anterior do atributo IO::Handle. Os métodos aceitam uma opcional EXPR, que, se fornecida, especifica o novo valor para o atributo IO::Handler em questão. Se não fornecido, muitos métodos nada fazem para o valor corrente--exceto para autoflush(), que sempre assume 1 para você, somente para ser diferente. Pelo fato de carregar a classe IO::Handle ser uma operação custosa, você deve aprender como usar as variáveis built-in padrão. Algumas destas variáveis são consideradas ``somente-leitura''. Isto significa que se você tentar acessar esta variável, diretamente ou indiretamente por meio de uma referência, você irá obter uma exceção em tempo de execução. Seja muito cauteloso quando modificar o valor padrão das diversas variáveis especiais descritas neste documento. Em muitos casos você precisa tornar locais estas variáveis antes de alterá-las, visto que se você não o fizer, a alteração pode afetar outros módulos que dependem dos valores padrão das variáveis especiais que você tenha alterado. Esta é uma das formas corretas de ler o arquivo inteiro de uma vez:

    open my $fh, "foo" or die $!;

    local $/; # enable localized slurp mode

    my $content = <$fh>;

    close $fh;

Mas o código seguinte é muito ruim:

    open my $fh, "foo" or die $!;

    undef $/; # enable slurp mode

    my $content = <$fh>;

    close $fh;

visto que algum outro módulo, pode querer ler dados de algum arquivo no ``modo linha`` padrão, deste modo se o código que nós apresentamos neste instante for executado, o valor global de $/ e agora alterado para qualquer outro código rodando dentro do mesmo interpretador Perl. Habitualmente quando uma variável é tornada local você deseja assegurar que estas alterações afetem o mais curto escopo possível. Assim a menos que você já adentre algum curto {} bloco, você deve criar uma você mesmo. Por exemplo:

    my $content = '';

    open my $fh, "foo" or die $!;

        local $/;

        $content = <$fh>;

    close $fh;

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

    for (1..5){

        nasty_break();

        print "$_ ";

    sub nasty_break {

        $_ = 5;

        # faça alguma coisa com $_

Você provavelmente estava à espera deste código imprimir:

    1 2 3 4 5

mas ao invés disso você obteve:

    5 5 5 5 5

Porque? Porque nasty_break() modifica $_ sem torná-la local primeiro. A correção é adicionar local():

        local $_ = 5;

Isto é fácil para notar o problema no tal pequeno exemplo, mas em código mais complicado você verá dificuldades se não tornar locais as alterações para variáveis especiais. A lista a seguir está ordenada por variáveis escalares primeiro, depois por arrays, e por fim os hashes.

$ARG

$_

A entrada padrão e o espaço de combinação de padrão. Os pares abaixo são

equivalentes:

    while (<>) {...}    # equivalente apenas em while!

    while (defined($_ = <>)) {...}

    /^Subject:/

    $_ =~ /^Subject:/

    tr/a-z/A-Z/

    $_ =~ tr/a-z/A-Z/

    chomp

    chomp($_)

Aqui estão os lugares onde Perl assumirá $_ se você não especificar algo sobre

o qual irá operar:

ord()

-f

-d

-t

print()

m//

s///

tr///

=~

foreach

grep()

<FH>

while

$a
$b: Variáveis especiais de pacote quando se usa sort(), veja sort in the perlfunc manpage. Por; causa desta excepcionalidade $a e $b não precisam ser declaradas (utilizando; use vars, ou our()) mesmo quando se utiliza o pragma strict 'vars'.; Don't lexicalize them with my $a or my $b if you want to be able to use; them in the sort() comparison block or function.

$<digits>

Contém o sub padrão do correspondente grupo de parênteses de captura da última

combinação de padrão, não contando padrões combinados no bloco aninhado que já

tenha sido terminado. (Mnemônico: semelhante a \digits.) Estas variáveis são

todas somente-leitura e dinamicamente escopadas para o BLOCK corrente.

$MATCH

$&

A string combinada pela última bem sucedida combinação de padrão (não contando

qualquer combinação oculta dentro de um BLOCO ou eval(), anexo pelo corrente

BLOCO). (Mnemônico: semelhante ao & em alguns editores.) Esta variável é

somente-leitura e dinamicamente escopada para o BLOCK corrente.

O uso desta variável em qualquer parte em um programa impõe uma considerável

penalidade na performance sobre todas as expressões regulares combinadas. Veja

BUGS.

$PREMATCH

$`

A string que precede qualquer coisa que foi combinada pela última bem sucedida

combinação de padrão (não contando qualquer combinação oculta dentro de um

BLOCO ou eval anexo pelo corrente BLOCO). (Mnemônico: ` muitas vezes precede

a string entre aspas.) Esta variável é somente-leitura.

O uso desta variável em qualquer parte em um programa impõe uma considerável

penalidade na performance sobre todas as expressões regulares combinadas. Veja

BUGS.

$POSTMATCH

$'

A string posterior a qualquer coisa que foi combinada pela última bem sucedida

combinação de padrão (não contanto qualquer combinação oculta dentro de um

BLOCO ou eval() anexo pelo corrente BLOCO). (Mnemônico: ' muitas vezes

sucede uma string entre aspas.) Exemplo:

    local $_ = 'abcdefghi';

    /def/;

    print "$`:$&:$'\n";          # imprime abc:def:ghi

Esta variável é somente-leitura e dinamicamente escopada para o BLOCK corrente.

O uso desta variável em qualquer parte em um programa impõe uma considerável

penalidade na performance sobre todas as expressões regulares combinadas. Veja

BUGS.

$LAST_PAREN_MATCH

$+

O texto combinado pelos últimos parênteses da última bem sucedida busca de

padrão. Isto é útil se você não sabe qual grupo de padrões alternativos

combinou. Por exemplo:

    /Version: (.*)|Revision: (.*)/ && ($rev = $+);

(Mnemonic: é positivo e olhando adiante.) Esta variável é somente-leitura e

dinamicamente escopada para o BLOCO corrente.

$^N

The text matched by the used group most-recently closed (i.e. the group

with the rightmost closing parenthesis) of the last successful search

pattern. (Mnemonic: the (possibly) Nested parenthesis that most

recently closed.)

This is primarily used inside (?{...}) blocks for examining text

recently matched. For example, to effectively capture text to a variable

(in addition to $1, $2, etc.), replace (...) with

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

By setting and then using $var in this way relieves you from having to

worry about exactly which numbered set of parentheses they are.

Esta variável é dinamicamente escopada para o BLOCK corrente.

@LAST_MATCH_END

@+

Este array mantém os deslocamentos das extremidades da última bem sucedida sub

combinação no corrente ativo escopo dinâmico. $+[0] é o deslocamento dentro

da string da extremidade da combinação inteira. Este é o mesmo valor com o qual

a função pos retorna quando chamada sobre a variável que está sendo

combinada em contraste. O n elemento deste array mantém o deslocamento da

n sub combinação, assim $+[1] é o deslocamento passado quando $1 termina,

$+[2] é o deslocamento passado quando $2 termina, e assim adiante. Você pode

usar $#+ para determinar quantos sub grupos existem na última bem sucedida

combinação. Veja os exemplos dados para a variável @-.

$*

Set to a non-zero integer value to do multi-line matching within a

string, 0 (or undefined) to tell Perl that it can assume that strings

contain a single line, for the purpose of optimizing pattern matches.

Pattern matches on strings containing multiple newlines can produce

confusing results when $* is 0 or undefined. Default is undefined.

(Mnemonic: * matches multiple things.) This variable influences the

interpretation of only ^ and $. A literal newline can be searched

for even when $* == 0.

Use of $* is deprecated in modern Perl, supplanted by

the /s and /m modifiers on pattern matching.

Assigning a non-numerical value to $* triggers a warning (and makes

$* act if $* == 0), while assigning a numerical value to $*

makes that an implicit int is applied on the value.

HANDLE->input_line_number(EXPR)

$INPUT_LINE_NUMBER

$NR

$.

Número da linha corrente do último filehandle acessado.

Cada filehandle em Perl conta o número de linhas que foram lidas dele.

(Dependendo do valor de $/, a idéia do Perl do que constitui uma linha pode

não combinar com a sua.) Quando uma linha é lida para um filehandle (via

readline() ou <>), ou quando tell() ou seek() são chamados sobre ela,

$. torna-se um apelido para o contador de linhas para aqule filehandle.

You can adjust the counter by assigning to $., but this will not actually

move the seek pointer. Localizing $. will not localize the filehandle's

line count>. Instead, it will localize perl's notion of which filehandle $.

is currently aliased to.

$. is reset when the filehandle is closed, but not when an open

filehandle is reopened without an intervening close(). For more

details, see I/O Operators in the perlop manpage. Because <> never does

an explicit close, line numbers increase across ARGV files (but see

examples in eof in the perlfunc manpage).

You can also use HANDLE->input_line_number(EXPR) to access the

line counter for a given filehandle without having to worry about

which handle you last accessed.

(Mnemonic: many programs use ``.'' to mean the current line number.)

IO::Handle->input_record_separator(EXPR)

$INPUT_RECORD_SEPARATOR

$RS

$/

O separador de registros de entrada, nova linha por padrão. This

influences Perl's idea of what a ``line'' is. Works like awk's RS

variable, including treating empty lines as a terminator if set to

the null string. (An empty line cannot contain any spaces

or tabs.) You may set it to a multi-character string to match a

multi-character terminator, or to undef to read through the end

of file. Setting it to "\n\n" means something slightly

different than setting to "", if the file contains consecutive

empty lines. Setting to "" will treat two or more consecutive

empty lines as a single empty line. Setting to "\n\n" will

blindly assume that the next input character belongs to the next

paragraph, even if it's a newline. (Mnemonic: / delimits

line boundaries when quoting poetry.)

    local $/;           # enable "slurp" mode

    local $_ = <FH>;    # whole file now here

    s/\n[ \t]+/ /g;

Remember: the value of $/ is a string, not a regex. awk has to be

better for something. smile

Setting $/ to a reference to an integer, scalar containing an integer, or

scalar that's convertible to an integer will attempt to read records

instead of lines, with the maximum record size being the referenced

integer. So this:

    local $/ = \32768; # or \"32768", or \$var_containing_32768

    open my $fh, $myfile or die $!;

    local $_ = <$fh>;

will read a record of no more than 32768 bytes from FILE. If you're

not reading from a record-oriented file (or your OS doesn't have

record-oriented files), then you'll likely get a full chunk of data

with every read. If a record is larger than the record size you've

set, you'll get the record back in pieces.

On VMS, record reads are done with the equivalent of sysread,

so it's best not to mix record and non-record reads on the same

file. (This is unlikely to be a problem, because any file you'd

want to read in record mode is probably unusable in line mode.)

Non-VMS systems do normal I/O, so it's safe to mix record and

non-record reads of a file.

See also Newlines in the perlport manpage. Also see $..

HANDLE->autoflush(EXPR)

$OUTPUT_AUTOFLUSH

$|

If set to nonzero, forces a flush right away and after every write

or print on the currently selected output channel. Default is 0

(regardless of whether the channel is really buffered by the

system or not; $| tells you only whether you've asked Perl

explicitly to flush after each write). STDOUT will

typically be line buffered if output is to the terminal and block

buffered otherwise. Setting this variable is useful primarily when

you are outputting to a pipe or socket, such as when you are running

a Perl program under rsh and want to see the output as it's

happening. This has no effect on input buffering. See getc in the perlfunc manpage

for that. (Mnemonic: when you want your pipes to be piping hot.)

IO::Handle->output_field_separator EXPR

$OUTPUT_FIELD_SEPARATOR

$OFS

$,

O separador de campos de saída para o operador print. Ordinarily the

print operator simply prints out its arguments without further

adornment. To get behavior more like awk, set this variable as

you would set awk's OFS variable to specify what is printed

between fields. (Mnemonic: what is printed when there is a ``,'' in

your print statement.)

IO::Handle->output_record_separator EXPR

$OUTPUT_RECORD_SEPARATOR

$ORS

$\

O separador de registros de saída para o operador print. Ordinarily the

print operator simply prints out its arguments as is, with no

trailing newline or other end-of-record string added. To get

behavior more like awk, set this variable as you would set

awk's ORS variable to specify what is printed at the end of the

print. (Mnemonic: you set $\ instead of adding ``\n'' at the

end of the print. Also, it's just like $/, but it's what you

get ``back'' from Perl.)

$LIST_SEPARATOR

$``

This is like $, except that it applies to array and slice values

interpolated into a double-quoted string (or similar interpreted

string). Default is a space. (Mnemonic: obvious, I think.)

$SUBSCRIPT_SEPARATOR

$SUBSEP

$;

O separador de subscript para emulação de array multidimensional. Se você

referir um elemento de um hash como:

    $foo{$a,$b,$c}

isto realmente significa:

    $foo{join($;, $a, $b, $c)}

Mas não coloque

    @foo{$a,$b,$c}      # a slice--note the @

que significa

    ($foo{$a},$foo{$b},$foo{$c})

Padrão é ``\034'', o mesmo que SUBSEP in awk. If your

keys contain binary data there might not be any safe value for $;.

(Mnemonic: comma (the syntactic subscript separator) is a

semi-semicolon. Yeah, I know, it's pretty lame, but $, is already

taken for something more important.)

Consider using ``real'' multidimensional arrays as described

in the perllol manpage.

$#

O formato de saída para impressão de números. This variable is a half-hearted

attempt to emulate awk's OFMT variable. There are times, however,

when awk and Perl have differing notions of what counts as

numeric. The initial value is ``%.ng'', where n is the value

of the macro DBL_DIG from your system's float.h. This is different from

awk's default OFMT setting of ``%.6g'', so you need to set $#

explicitly to get awk's value. (Mnemonic: # is the number sign.)

Use of $# is deprecated.

HANDLE->format_page_number(EXPR)

$FORMAT_PAGE_NUMBER

$%

O número da página corrente do canal de saída atualmente selecionado.

Usado com formats.

(Mnemonic: % is page number in nroff.)

HANDLE->format_lines_per_page(EXPR)

$FORMAT_LINES_PER_PAGE

$=

O comprimento da página corrente (linhas imprimíveis) do canal de

saída atualmente selecionado. Padrão é 60.

Usado com formats.

(Mnemonic: = has horizontal lines.)

HANDLE->format_lines_left(EXPR)

$FORMAT_LINES_LEFT

$-

O número de linhas restantes da página do corrente canal de saída selecionado.

Usado com formats.

(Mnemônico: lines_on_page - lines_printed.)

@LAST_MATCH_START

@-

$-[0] is the offset of the start of the last successful match.

$-[n] is the offset of the start of the substring matched by

n-th subpattern, or undef if the subpattern did not match.

Thus after a match against $_, $& coincides with substr $_, $-[0],

$+[0] - $-[0]>. Similarly, $n coincides with substr $_, $-[n],

$+[n] - $-[n]> if $-[n] is defined, and $+ coincides with

substr $_, $-[$#-], $+[$#-] - $-[$#-]. One can use $#- to find the last

matched subgroup in the last successful match. Contrast with

$#+, the number of subgroups in the regular expression. Compare

with @+.

This array holds the offsets of the beginnings of the last

successful submatches in the currently active dynamic scope.

$-[0] is the offset into the string of the beginning of the

entire match. The nth element of this array holds the offset

of the nth submatch, so $-[1] is the offset where $1

begins, $-[2] the offset where $2 begins, and so on.

After a match against some variable $var:

$` é a mesma coisa que substr($var, 0, $-[0])
$& é a mesma coisa que substr($var, $-[0], $+[0] - $-[0])
$' é a mesma coisa que substr($var, $+[0])
$1 é a mesma coisa que substr($var, $-[1], $+[1] - $-[1])
$2 é a mesma coisa que substr($var, $-[2], $+[2] - $-[2])
$3 é a mesma coisa que substr $var, $-[3], $+[3] - $-[3])

HANDLE->format_name(EXPR)

$FORMAT_NAME

$~

O nome do formato do relatório corrente para o canal de saída atualmente

selecionado. Padrão é o nome do filehandle. (Mnemonic: brother to

$^.)

HANDLE->format_top_name(EXPR)

$FORMAT_TOP_NAME

$^

O nome do formato topo-da-página corrente para o canal de saída atualmente

selecionado. Padrão é o nome do filehandle com _TOP apensado.

(Mnemonic: points to top of page.)

IO::Handle->format_line_break_characters EXPR

$FORMAT_LINE_BREAK_CHARACTERS

$:

The current set of characters after which a string may be broken to

fill continuation fields (starting with ^) in a format. Default is

`` \n-'', to break on whitespace or hyphens. (Mnemonic: a ``colon'' in

poetry is a part of a line.)

IO::Handle->format_formfeed EXPR

$FORMAT_FORMFEED

$^L

What formats output as a form feed. Default is \f.

$ACCUMULATOR

$^A

The current value of the write() accumulator for format() lines. A format

contains formline() calls that put their result into $^A. After

calling its format, write() prints out the contents of $^A and empties.

So you never really see the contents of $^A unless you call

formline() yourself and then look at it. See the perlform manpage and

formline() in the perlfunc manpage.

$CHILD_ERROR

$?

The status returned by the last pipe close, backtick (``) command,

successful call to wait() or waitpid(), or from the system()

operator. This is just the 16-bit status word returned by the

wait() system call (or else is made up to look like it). Thus, the

exit value of the subprocess is really ($? >> 8), and

$? & 127 gives which signal, if any, the process died from, and

$? & 128 reports whether there was a core dump. (Mnemonic:

similar to sh and ksh.)

Additionally, if the h_errno variable is supported in C, its value

is returned via $? if any gethost*() function fails.

If you have installed a signal handler for SIGCHLD, the

value of $? will usually be wrong outside that handler.

Inside an END subroutine $? contains the value that is going to be

given to exit(). You can modify $? in an END subroutine to

change the exit status of your program. For example:

    END {

            $? = 1 if $? == 255;  # die would make it 255

Under VMS, the pragma use vmsish 'status' makes $? reflect the

actual VMS exit status, instead of the default emulation of POSIX

status; see $? in the perlvms manpage for details.

Veja também Indicadores de Erro.

${^ENCODING}

The object reference to the Encode object that is used to convert

the source code to Unicode. Thanks to this variable your perl script

does not have to be written in UTF-8. Default is undef. The direct

manipulation of this variable is highly discouraged. See the encoding manpage

for more details.

$OS_ERROR

$ERRNO

$!

If used numerically, yields the current value of the C errno

variable, or in other words, if a system or library call fails, it

sets this variable. This means that the value of $! is meaningful

only immediately after a failure:

    if (open(FH, $filename)) {

        # Here $! is meaningless.

...

    } else {

        # ONLY here is $! meaningful.

...

        # Already here $! might be meaningless.

    # Since here we might have either success or failure,

    # here $! is meaningless.

In the above meaningless stands for anything: zero, non-zero,

undef. A successful system or library call does not set

the variable to zero.

If used as a string, yields the corresponding system error string.

You can assign a number to $! to set errno if, for instance,

you want "$!" to return the string for error n, or you want

to set the exit value for the die() operator. (Mnemonic: What just

went bang?)

Veja também Indicadores de Erro.

%!

Each element of %! has a true value only if $! is set to that

value. For example, $!{ENOENT} is true if and only if the current

value of $! is ENOENT; that is, if the most recent error was

``No such file or directory'' (or its moral equivalent: not all operating

systems give that exact error, and certainly not all languages).

To check if a particular key is meaningful on your system, use

exists $!{the_key}; for a list of legal keys, use keys %!.

See the Errno manpage for more information, and also see above for the

validity of $!.

$EXTENDED_OS_ERROR

$^E

Error information specific to the current operating system. At

the moment, this differs from $! under only VMS, OS/2, and Win32

(and for MacPerl? ). On all other platforms, $^E is always just

the same as $!.

Under VMS, $^E provides the VMS status value from the last

system error. This is more specific information about the last

system error than that provided by $!. This is particularly

important when $! is set to EVMSERR.

Under OS/2, $^E is set to the error code of the last call to

OS/2 API either via CRT, or directly from perl.

Under Win32, $^E always returns the last error information

reported by the Win32 call GetLastError() which describes

the last error from within the Win32 API. Most Win32-specific

code will report errors via $^E. ANSI C and Unix-like calls

set errno and so most portable Perl code will report errors

via $!.

Caveats mentioned in the description of $! generally apply to

$^E, also. (Mnemonic: Extra error explanation.)

Veja também Indicadores de Erro.

$EVAL_ERROR

$@

A mensagem de erro de sintaxe do Perl para a última operação eval(). Se $@ é

uma string nula, o último eval() analisado e executado corretamente (ainda que

as operações invocadas por você possam ter falhado na forma normal).

(Mnemônico: Onde ficou ``aquele'' erro de sintaxe?)

Mensagens de advertência não são coletadas nesta variável. Se conseguir,

entretanto, crie uma rotina para processar advertências definindo

$SIG{__WARN__} como descrito abaixo.

Veja também Indicadores de Erro.

$PROCESS_ID

$PID

$$

O número do processo do Perl executando neste script. Você deveria considerar

esta variável somente-leitura, entretanto será alterada através de chamada

fork(). (Mnemônico: o mesmo que shells.)

Nota para usuários Linux: sobre Linux, as funções C getpid() e getppid()

retornam valores diferentes para diferentes threads. A fim de ser portável,

este comportamento não é refletido por $$, cujo valor permanece consistente

através de todas as threads. Se você deseja chamar basicamente getpid(),

você pode usar o módulo CPAN Linux::Pid.

$REAL_USER_ID

$UID

$<

The real uid of this process. (Mnemonic: it's the uid you came from,

if you're running setuid.) You can change both the real uid and

the effective uid at the same time by using POSIX::setuid(). Since

changes to $< require a system call, check $! after a change attempt to

detect any possible errors.

$EFFECTIVE_USER_ID

$EUID

$>

The effective uid of this process. Example:

    $< = $>;            # set real to effective uid

    ($<,$>) = ($>,$<);  # swap real and effective uid

You can change both the effective uid and the real uid at the same

time by using POSIX::setuid(). Changes to $> require a check to $!

to detect any possible errors after an attempted change.

(Mnemonic: it's the uid you went to, if you're running setuid.)

$< and $> can be swapped only on machines

supporting setreuid().

$REAL_GROUP_ID

$GID

$(

The real gid of this process. If you are on a machine that supports

membership in multiple groups simultaneously, gives a space separated

list of groups you are in. The first number is the one returned by

getgid(), and the subsequent ones by getgroups(), one of which may be

the same as the first number.

However, a value assigned to $( must be a single number used to

set the real gid. So the value given by $( should not be assigned

back to $( without being forced numeric, such as by adding zero.

You can change both the real gid and the effective gid at the same

time by using POSIX::setgid(). Changes to $( require a check to $!

to detect any possible errors after an attempted change.

(Mnemonic: parentheses are used to group things. The real gid is the

group you left, if you're running setgid.)

$EFFECTIVE_GROUP_ID

$EGID

$)

The effective gid of this process. If you are on a machine that

supports membership in multiple groups simultaneously, gives a space

separated list of groups you are in. The first number is the one

returned by getegid(), and the subsequent ones by getgroups(), one of

which may be the same as the first number.

Similarly, a value assigned to $) must also be a space-separated

list of numbers. The first number sets the effective gid, and

the rest (if any) are passed to setgroups(). To get the effect of an

empty list for setgroups(), just repeat the new effective gid; that is,

to force an effective gid of 5 and an effectively empty setgroups()

list, say $) = "5 5" .

You can change both the effective gid and the real gid at the same

time by using POSIX::setgid() (use only a single numeric argument).

Changes to $) require a check to $! to detect any possible errors

after an attempted change.

(Mnemonic: parentheses are used to group things. The effective gid

is the group that's right for you, if you're running setgid.)

$<, $>, $( and $) can be set only on

machines that support the corresponding set[re][ug]id() routine. $(

and $) can be swapped only on machines supporting setregid().

$PROGRAM_NAME

$0

Contains the name of the program being executed.

On some (read: not all) operating systems assigning to $0 modifies

the argument area that the ps program sees. On some platforms you

may have to use special ps options or a different ps to see the

changes. Modifying the $0 is more useful as a way of indicating the

current program state than it is for hiding the program you're

running. (Mnemonic: same as sh and ksh.)

Note that there are platform specific limitations on the the maximum

length of $0. In the most extreme case it may be limited to the

space occupied by the original $0.

In some platforms there may be arbitrary amount of padding, for

example space characters, after the modified name as shown by ps.

In some platforms this padding may extend all the way to the original

length of the argument area, no matter what you do (this is the case

for example with Linux 2.2).

Note for BSD users: setting $0 does not completely remove ``perl''

from the the ps(1) manpage output. For example, setting $0 to "foobar" may

result in "perl: foobar (perl)" (whether both the "perl: " prefix

and the `` (perl)'' suffix are shown depends on your exact BSD variant

and version). This is an operating system feature, Perl cannot help it.

In multithreaded scripts Perl coordinates the threads so that any

thread may modify its copy of the $0 and the change becomes visible

to the ps(1) manpage (assuming the operating system plays along). Note that the

the view of $0 the other threads have will not change since they

have their own copies of it.

$[

The index of the first element in an array, and of the first character

in a substring. Default is 0, but you could theoretically set it

to 1 to make Perl behave more like awk (or Fortran) when

subscripting and when evaluating the index() and substr() functions.

(Mnemonic: [ begins subscripts.)

As of release 5 of Perl, assignment to $[ is treated as a compiler

directive, and cannot influence the behavior of any other file.

(That's why you can only assign compile-time constants to it.)

Its use is highly discouraged.

Note that, unlike other compile-time directives (such as the strict manpage),

assignment to $[ can be seen from outer lexical scopes in the same file.

However, you can use local() on it to strictly bound its value to a

lexical block.

$]

The version + patchlevel / 1000 of the Perl interpreter. This variable

can be used to determine whether the Perl interpreter executing a

script is in the right range of versions. (Mnemonic: Is this version

of perl in the right bracket?) Example:

    warn "No checksumming!\n" if $] < 3.019;

See also the documentation of use VERSION and require VERSION

for a convenient way to fail if the running Perl interpreter is too old.

When testing the variable, to steer clear of floating point

inaccuracies you might want to prefer the inequality tests <

and > to the tests containing equivalence: <=, ==,

and >=.

The floating point representation can sometimes lead to inaccurate

numeric comparisons. See $^V for a more modern representation of

the Perl version that allows accurate string comparisons.

$COMPILING

$^C

The current value of the flag associated with the -c switch.

Mainly of use with -MO=... to allow code to alter its behavior

when being compiled, such as for example to AUTOLOAD at compile

time rather than normal, deferred loading. See the perlcc manpage. Setting

$^C = 1 is similar to calling B::minus_c.

$DEBUGGING

$^D

O correte valor das flags de depuração. (Mnemônico: valor da opção -D.)

Poder ser lida e ajustada. Como seu equivalente de linha de comando, você pode

usar números ou valores simbólicos, por exemplo $^D = 10 ou $^D = "st".

$SYSTEM_FD_MAX

$^F

The maximum system file descriptor, ordinarily 2. System file

descriptors are passed to exec()ed processes, while higher file

descriptors are not. Also, during an open(), system file descriptors are

preserved even if the open() fails. (Ordinary file descriptors are

closed before the open() is attempted.) The close-on-exec

status of a file descriptor will be decided according to the value of

$^F when the corresponding file, pipe, or socket was opened, not the

time of the exec().

$^H

WARNING: This variable is strictly for internal use only. Its availability,

behavior, and contents are subject to change without notice.

This variable contains compile-time hints for the Perl interpreter. At the

end of compilation of a BLOCK the value of this variable is restored to the

value when the interpreter started to compile the BLOCK.

When perl begins to parse any block construct that provides a lexical scope

(e.g., eval body, required file, subroutine body, loop body, or conditional

block), the existing value of $^H is saved, but its value is left unchanged.

When the compilation of the block is completed, it regains the saved value.

Between the points where its value is saved and restored, code that

executes within BEGIN blocks is free to change the value of $^H.

This behavior provides the semantic of lexical scoping, and is used in,

for instance, the use strict pragma.

The contents should be an integer; different bits of it are used for

different pragmatic flags. Here's an example:

    sub add_100 { $^H |= 0x100 }

    sub foo {

        BEGIN { add_100() }

        bar->baz($boon);

Consider what happens during execution of the BEGIN block. At this point

the BEGIN block has already been compiled, but the body of foo() is still

being compiled. The new value of $^H will therefore be visible only while

the body of foo() is being compiled.

Substitution of the above BEGIN block with:

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

demonstrates how use strict 'vars' is implemented. Here's a conditional

version of the same lexical pragma:

    BEGIN { require strict; strict->import('vars') if $condition }

%^H

ADVERTÊNCIA: Esta variável é estritamente para uso interno somente. Sua

avaliabilidade comportamental, e conteúdo são assunto para mudanças sem

notificação.

O hash %^H provê o mesmo escopo semântico que $^H. Isto se faz útil para

implementação de pragmas lexicalmente escopados.

$INPLACE_EDIT

$^I

O corrente valor da extensão edição local. Use undef para desabilitar edição

local. (Mnemônico: valor da opção -i.)

$^M

By default, running out of memory is an untrappable, fatal error.

However, if suitably built, Perl can use the contents of $^M

as an emergency memory pool after die()ing. Suppose that your Perl

were compiled with -DPERL_EMERGENCY_SBRK and used Perl's malloc.

Then

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

would allocate a 64K buffer for use in an emergency. See the

INSTALL file in the Perl distribution for information on how to

enable this option. To discourage casual use of this advanced

feature, there is no English long name for this variable.

$OSNAME

$^O

The name of the operating system under which this copy of Perl was

built, as determined during the configuration process. The value

is identical to $Config{'osname'}. See also the Config manpage and the

-V command-line switch documented in the perlrun manpage.

In Windows platforms, $^O is not very helpful: since it is always

MSWin32, it doesn't tell the difference between

95/98/ME/NT/2000/XP/CE/.NET. Use Win32::GetOSName() or

Win32::GetOSVersion() (see the Win32 manpage and the perlport manpage) to distinguish

between the variants.

${^OPEN}

Uma variável interna usada por PerlIO? . A string tem duas partes, separadas por

um byte \0, a primeira parte descreve as camadas de entrada, a segunda parte

descreve as camadas de saída.

$PERLDB

$^P

The internal variable for debugging support. The meanings of the

various bits are subject to change, but currently indicate:

x01

x02

x04

x08

x10

x20

x40

x80

goto &subroutine

x100

x200

x400

$LAST_REGEXP_CODE_RESULT

$^R

O resultado da avaliação da última bem sucedida (?{ code }) asserção de

expressão regular bem sucedida (veja the perlre manpage).

May be written to.

$EXCEPTIONS_BEING_CAUGHT

$^S

Current state of the interpreter.

    $^S         State

    ---------   -------------------

    undef       Parsing module/eval

    true (1)    Executing an eval

    false (0)   Otherwise

The first state may happen in $SIG{__DIE__} and $SIG{__WARN__} handlers.

$BASETIME

$^T

O tempo desde que o programa começou a execução, em segundos desde o epoch

(começando de 1970). Os valores retornados pelos testes de arquivo -M,

-A, e -C são baseados neste valor.

${^TAINT}

Reflete se o modo taint está ligado ou desligado. 1 para ligado (o programa foi

executado com -T), 0 para desligado, -1 quando somente avisos taint estão

habilitados (ou seja, com -t ou -TU).

${^UNICODE}

Reflete certos ajustes Unicode do Perl. Veja documentação the perlrun manpage para a

opção -C para mais informação sobre os possíveis valores. Esta variável é

ajustada durante a inicialização do Perl e é em seguida somente-leitura.

$PERL_VERSION

$^V

The revision, version, and subversion of the Perl interpreter, represented

as a string composed of characters with those ordinals. Thus in Perl v5.6.0

it equals chr(5) . chr(6) . chr(0) and will return true for

$^V eq v5.6.0. Note that the characters in this string value can

potentially be in Unicode range.

This can be used to determine whether the Perl interpreter executing a

script is in the right range of versions. (Mnemonic: use ^V for Version

Control.) Example:

    warn "No \"our\" declarations!\n" if $^V and $^V lt v5.6.0;

To convert $^V into its string representation use sprintf()'s

"%vd" conversion:

    printf "version is v%vd\n", $^V;  # Perl's version

See the documentation of use VERSION and require VERSION

for a convenient way to fail if the running Perl interpreter is too old.

See also $] for an older representation of the Perl version.

$WARNING

$^W

O corrente valor de opção de advertência, inicialmente verdadeiro se -w foi

usado, falso do contrário, mas diretamente modificável. (Mnemônico: relacionado

a opção -w.) Veja também the warnings manpage.

${^WARNING_BITS}

O corrente ajuste da verificação de advertência habilitado pelo pragma use

warnings>. Veja a documentação de warnings para mais detalhes.

$EXECUTABLE_NAME

$^X

The name used to execute the current copy of Perl, from C's

argv[0].

Depending on the host operating system, the value of $^X may be

a relative or absolute pathname of the perl program file, or may

be the string used to invoke perl but not the pathname of the

perl program file. Also, most operating systems permit invoking

programs that are not in the PATH environment variable, so there

is no guarantee that the value of $^X is in PATH. For VMS, the

value may or may not include a version number.

You usually can use the value of $^X to re-invoke an independent

copy of the same perl that is currently running, e.g.,

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

But recall that not all operating systems support forking or

capturing of the output of commands, so this complex statement

may not be portable.

It is not safe to use the value of $^X as a path name of a file,

as some operating systems that have a mandatory suffix on

executable files do not require use of the suffix when invoking

a command. To convert the value of $^X to a path name, use the

following statements:

  # Build up a set of file names (not command names).

  use Config;

  $this_perl = $^X;

  if ($^O ne 'VMS')

     {$this_perl .= $Config{_exe}

          unless $this_perl =~ m/$Config{_exe}$/i;}

Because many operating systems permit anyone with read access to

the Perl program file to make a copy of it, patch the copy, and

then execute the copy, the security-conscious Perl programmer

should take care to invoke the installed copy of perl, not the

copy referenced by $^X. The following statements accomplish

this goal, and produce a pathname that can be invoked as a

command or referenced as a file.

  use Config;

  $secure_perl_path = $Config{perlpath};

  if ($^O ne 'VMS')

     {$secure_perl_path .= $Config{_exe}

          unless $secure_perl_path =~ m/$Config{_exe}$/i;}

ARGV

The special filehandle that iterates over command-line filenames in

@ARGV. Usually written as the null filehandle in the angle operator

<>. Note that currently ARGV only has its magical effect

within the <> operator; elsewhere it is just a plain filehandle

corresponding to the last file opened by <>. In particular,

passing \*ARGV as a parameter to a function that expects a filehandle

may not cause your function to automatically read the contents of all the

files in @ARGV.

$ARGV

contém o nome do corrente arquivo quando lendo a partir de <>.

@ARGV

The array @ARGV contains the command-line arguments intended for

the script. $#ARGV is generally the number of arguments minus

one, because $ARGV[0] is the first argument, not the program's

command name itself. See $0 for the command name.

ARGVOUT

The special filehandle that points to the currently open output file

when doing edit-in-place processing with -i. Useful when you have

to do a lot of inserting and don't want to keep modifying $_. See

the perlrun manpage for the -i switch.

@F

The array @F contains the fields of each line read in when autosplit

mode is turned on. See the perlrun manpage for the -a switch. This array

is package-specific, and must be declared or given a full package name

if not in package main when running under strict 'vars'.

@INC

The array @INC contains the list of places that the do EXPR,

require, or use constructs look for their library files. It

initially consists of the arguments to any -I command-line

switches, followed by the default Perl library, probably

/usr/local/lib/perl, followed by ``.'', to represent the current

directory. (``.'' will not be appended if taint checks are enabled, either by

-T or by -t.) If you need to modify this at runtime, you should use

the use lib pragma to get the machine-dependent library properly

loaded also:

    use lib '/mypath/libdir/';

    use SomeMod;

You can also insert hooks into the file inclusion system by putting Perl

code directly into @INC. Those hooks may be subroutine references, array

references or blessed objects. See require in the perlfunc manpage for details.

@_

Dentro de uma sub rotina o array @_ contém os parâmetros passados para essa

sub rotina. Veja the perlsub manpage.

%INC

The hash %INC contains entries for each filename included via the

do, require, or use operators. The key is the filename

you specified (with module names converted to pathnames), and the

value is the location of the file found. The require

operator uses this hash to determine whether a particular file has

already been included.

If the file was loaded via a hook (e.g. a subroutine reference, see

require in the perlfunc manpage for a description of these hooks), this hook is

by default inserted into %INC in place of a filename. Note, however,

that the hook may have set the %INC entry by itself to provide some more

specific info.

%ENV

$ENV{expr}

O hash %ENV contém seu ambiente corrente. Ajustando um valor em ENV muda o

ambiente para qualquer processo filho subsequente de fork() por você.

%SIG

$SIG{expr}

The hash %SIG contains signal handlers for signals. For example:

    sub handler {       # 1st argument is signal name

        my($sig) = @_;

        print "Caught a SIG$sig--shutting down\n";

        close(LOG);

        exit(0);

    $SIG{'INT'}  = \&handler;

    $SIG{'QUIT'} = \&handler;

...

    $SIG{'INT'}  = 'DEFAULT';   # restore default action

    $SIG{'QUIT'} = 'IGNORE';    # ignore SIGQUIT

Using a value of 'IGNORE' usually has the effect of ignoring the

signal, except for the CHLD signal. See the perlipc manpage for more about

this special case.

Here are some other examples:

    $SIG{"PIPE"} = "Plumber";   # assumes main::Plumber (not recommended)

    $SIG{"PIPE"} = \&Plumber;   # just fine; assume current Plumber

    $SIG{"PIPE"} = *Plumber;    # somewhat esoteric

    $SIG{"PIPE"} = Plumber();   # oops, what did Plumber() return??

Be sure not to use a bareword as the name of a signal handler,

lest you inadvertently call it.

If your system has the sigaction() function then signal handlers are

installed using it. This means you get reliable signal handling.

The default delivery policy of signals changed in Perl 5.8.0 from

immediate (also known as ``unsafe'') to deferred, also known as

``safe signals''. See the perlipc manpage for more information.

Certain internal hooks can be also set using the %SIG hash. The

routine indicated by $SIG{__WARN__} is called when a warning message is

about to be printed. The warning message is passed as the first

argument. The presence of a WARN hook causes the ordinary printing

of warnings to STDERR to be suppressed. You can use this to save warnings

in a variable, or turn warnings into fatal errors, like this:

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

    eval $proggie;

The routine indicated by $SIG{__DIE__} is called when a fatal exception

is about to be thrown. The error message is passed as the first

argument. When a DIE hook routine returns, the exception

processing continues as it would have in the absence of the hook,

unless the hook routine itself exits via a goto, a loop exit, or a die().

The __DIE__ handler is explicitly disabled during the call, so that you

can die from a __DIE__ handler. Similarly for __WARN__.

Due to an implementation glitch, the $SIG{__DIE__} hook is called

even inside an eval(). Do not use this to rewrite a pending exception

in $@, or as a bizarre substitute for overriding CORE::GLOBAL::die().

This strange action at a distance may be fixed in a future release

so that $SIG{__DIE__} is only called if your program is about

to exit, as was the original intent. Any other use is deprecated.

__DIE__/__WARN__ handlers are very special in one respect:

they may be called to report (probable) errors found by the parser.

In such a case the parser may be in inconsistent state, so any

attempt to evaluate Perl code from such a handler will probably

result in a segfault. This means that warnings or errors that

result from parsing Perl should be used with extreme caution, like

this:

    require Carp if defined $^S;

    Carp::confess("Something wrong") if defined &Carp::confess;

    die "Something wrong, but could not load Carp to give backtrace...

         To see backtrace try starting Perl with -MCarp switch";

Here the first line will load Carp unless it is the parser who

called the handler. The second line will print backtrace and die if

Carp was available. The third line will be executed only if Carp was

not available.

See die in the perlfunc manpage, warn in the perlfunc manpage, eval in the perlfunc manpage, and

the warnings manpage for additional information.

Indicadores de Erro

As variáveis $@, $!, $^E, e $? contém informações sobre diferentes tipos de condições de erros que podem aparecer durante a execução do programa Perl. As variáveis são mostradas ordenadas pela ``distância'' entre o subsistema que reportam o erro e o processo Perl. Elas correspondem aos erros detectados pelo interpretador Perl, biblioteca C, sistema operacional, ou um programa externo, respectivamente. Para ilustrar as diferenças ente estas variáveis, considere a seguinte expressão Perl, que usa uma string ``aspa-simples'':

    eval q{

        open my $pipe, "/cdrom/install |" or die $!;

        my @res = <$pipe>;

        close $pipe or die "bad pipe: $?, $!";

};

Após a execução desta declaração todas as 4 variáveis podem ter sido ajustadas. $@ é ajustada se a string a ser eval-ed [avaliada] não compilar (isto pode acontecer se open ou close forem importadas com protótipos ruins), ou se o código Perl executado durante a avaliação died()d [morrer]. Nestes casos a valor de $@ é erro de compilação, ou o argumento para die (que interpolará $! e $?). (Veja também the Fatal manpage, ainda.) Quando a expressão eval() acima é executada, open(), <PIPE>, e close são traduzidas para chamadas de biblioteca C em tempo de execução e dali para o núcleo do sistema operacional. $! é ajustada para as bibliotecas C errno se uma destas chamadas falhar. Sob uma minoria dos sistemas operacionais, $^E pode conter um maior prolixo indicador de erro, assim como neste caso, ``CDROM tray not closed.'' Sistemas que não suportam mensagens de erro estendidas deixam $^E igual a $!. Por fim, $? poder ser ajustada para um valor diferente de 0 se o programa externo /cdrom/install falhar. Os oito bits superiores refletem as específicas condições de erro encontradas pelo programa (o valor exit() do programa). Os oito bits inferiores refletem o modo de falha, como sinal de morte ou informações de descarga de memória. Veja the wait(2) manpage para detalhes. Em contraste com $! e ^E, que são ajustadas somente se condições de erro forem detectadas, a variável $? é ajustada em cada wait ou duto close, sobrescrevendo o valor antigo. Isto é mais parecido com $@, que em todo eval() sempre é ajustado em falha e limpo em sucesso. Para mais detalhes, veja as descrições individuais para $@, $!, $^E, e $?.

Technical Note on the Syntax of Variable Names

Variable names in Perl can have several formats. Usually, they must begin with a letter or underscore, in which case they can be arbitrarily long (up to an internal limit of 251 characters) and may contain letters, digits, underscores, or the special sequence :: or '. In this case, the part before the last :: or ' is taken to be a package qualifier; see the perlmod manpage. Perl variable names may also be a sequence of digits or a single punctuation or control character. These names are all reserved for special uses by Perl; for example, the all-digits names are used to hold data captured by backreferences after a regular expression match. Perl has a special syntax for the single-control-character names: It understands ^X (caret X) to mean the control-X character. For example, the notation $^W (dollar-sign caret W) is the scalar variable whose name is the single character control-W. This is better than typing a literal control-W into your program. Finally, new in Perl 5.6, Perl variable names may be alphanumeric strings that begin with control characters (or better yet, a caret). These variables must be written in the form ${^Foo}; the braces are not optional. ${^Foo} denotes the scalar variable whose name is a control-F followed by two o's. These variables are reserved for future special uses by Perl, except for the ones that begin with ^_ (control-underscore or caret-underscore). No control-character name that begins with ^_ will acquire a special meaning in any future version of Perl; such names may therefore be used safely in programs. $^_ itself, however, is reserved. Perl identifiers that begin with digits, control characters, or punctuation characters are exempt from the effects of the package declaration and are always forced to be in package main; they are also exempt from strict 'vars' errors. A few other names are also exempt in these ways:

        ENV             STDIN

        INC             STDOUT

        ARGV            STDERR

        ARGVOUT         _

SIG

In particular, the new special ${^_XYZ} variables are always taken to be in package main, regardless of any package declarations presently in scope.

voltar para o topo

BUGS

Due to an unfortunate accident of Perl's implementation, use English> imposes a considerable performance penalty on all regular expression matches in a program, regardless of whether they occur in the scope of use English. For that reason, saying use English> in libraries is strongly discouraged. See the Devel::SawAmpersand module documentation from CPAN ( http://www.cpan.org/modules/by-module/Devel/ ) for more information. Having to even think about the $^S variable in your exception handlers is simply wrong. $SIG{__DIE__} as currently implemented invites grievous and difficult to track down errors. Avoid it and use an END{} or CORE::GLOBAL::die override instead.

voltar para o topo

TRADUZINDO

Joenio Costa <joenio@perl.org.br> RonaldoLima

voltar para o topo

Pesquisar

Documentação

Artigos

Planeta

Eventos

Comunidade

NAME

DESCRIPTION

Nomes especiais

Indicadores de Erro

Technical Note on the Syntax of Variable Names

BUGS

TRADUZINDO