| perlvar - Perl predefined variables |
perlvar - Perl predefined variables
The following names have special meaning to Perl. Most of the punctuational names have reasonable mnemonics, or analogues in one of the shells. Nevertheless, if you wish to use the long variable names, you just need to say
use English;
at the top of your program. This will alias all the short names to the long names in the current package. Some of them even have medium names, generally borrowed from awk.
To go a step further, those variables that depend on the currently selected filehandle may instead be set by calling an object method on the FileHandle object. (Summary lines below for this contain the word HANDLE.) First you must say
use FileHandle;
after which you may use either
method HANDLE EXPR
or
HANDLE->method(EXPR)
Each of the methods returns the old value of the FileHandle attribute. The methods each take an optional EXPR, which if supplied specifies the new value for the FileHandle attribute in question. If not supplied, most of the methods do nothing to the current value, except for autoflush(), which will assume a 1 for you, just to be different.
A few of these variables are considered ``read-only''. This means that if you try to assign to this variable, either directly or indirectly through a reference, you'll raise a run-time exception.
while (<>) {...} # only equivalent in while!
while ($_ = <>) {...}
/^Subject:/
$_ =~ /^Subject:/
tr/a-z/A-Z/
$_ =~ tr/a-z/A-Z/
chop
chop($_)
(Mnemonic: underline is understood in certain operations.)
eval() enclosed by the current
BLOCK). (Mnemonic: like & in some editors.) This variable is read-only.
eval()
enclosed by the current BLOCK). (Mnemonic: ' often follows a quoted
string.) Example:
$_ = 'abcdefghi';
/def/;
print "$`:$&:$'\n"; # prints abc:def:ghi
This variable is read-only.
/Version: (.*)|Revision: (.*)/ && ($rev = $+);
(Mnemonic: be positive and forward looking.) This variable is read-only.
$*'' is 0. Default
is 0. (Mnemonic: * matches multiple things.) Note that this variable
only influences the interpretation of ``^'' and ``$''. A literal newline can
be searched for even when $* == 0.
Use of ``$*'' is deprecated in Perl 5.
<>'' never does an explicit close, line numbers increase
across ARGV files (but see examples under eof()). Localizing $. has
the effect of also localizing Perl's notion of ``the last read
filehandle''. (Mnemonic: many programs use ``.'' to mean the current line
number.)
"\n\n" means
something slightly different than setting it to "", if the file
contains consecutive blank lines. Setting it to "" will treat two or
more consecutive blank lines as a single blank line. Setting it to
"\n\n" will blindly assume that the next input character belongs to the
next paragraph, even if it's a newline. (Mnemonic: / is used to
delimit line boundaries when quoting poetry.)
undef $/;
$_ = <FH>; # whole file now here
s/\n[ \t]+/ /g;
$\'' instead of adding \n at the end of the
print. Also, it's just like /, but it's what you get ``back'' from
Perl.)
$,'' except that it applies to array values interpolated
into a double-quoted string (or similar interpreted string). Default
is a space. (Mnemonic: obvious, I think.)
$foo{$a,$b,$c}
it really means
$foo{join($;, $a, $b, $c)}
But don't put
@foo{$a,$b,$c} # a slice--note the @
which means
($foo{$a},$foo{$b},$foo{$c})
Default is ``\034'', the same as SUBSEP in awk. Note that 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'' multi-dimensional arrays in Perl 5.
$#'' explicitly to get awk's value. (Mnemonic: # is the
number sign.)
Use of ``$#'' is deprecated in Perl 5.
$^''.)
write() accumulator for format() lines. A format
contains formline() commands that put their result into $^A. After
calling its format, write() prints out the contents of $^A and empties.
So you never actually 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.
``) command,
or system() operator. Note that this is the status word returned by
the wait() system call, so the exit value of the subprocess is actually
($? >> 8). Thus on many systems, $? & 255 gives which signal,
if any, the process died from, and whether there was a core dump.
(Mnemonic: similar to sh and ksh.)
$!'' to be anything in particular unless you've gotten a
specific error return indicating a system error.) If used in a string
context, yields the corresponding system error string. You can assign
to ``$!'' in order 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?)
eval() command. If null, the
last eval() parsed and executed correctly (although the operations you
invoked may have failed in the normal fashion). (Mnemonic: Where was
the syntax error ``at''?)
Note that warning messages are not collected in this variable. You can, however, set up a routine to process warnings by setting $SIG{__WARN__} below.
$< = $>; # set real to effective uid
($<,$>) = ($>,$<); # swap real and effective uid
(Mnemonic: it's the uid you went TO, if you're running setuid.) Note:
``$<'' and ``$>'' can only be swapped on machines supporting setreuid().
Note: ``$<'', ``$>'', ``$('' and ``$)'' can only be set on machines
that support the corresponding set[re][ug]id() routine. ``$('' and ``$)''
can only be swapped on machines supporting setregid().
$0'' modifies the argument area that the ps(1)
program sees. This 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.)
index() and substr() functions. (Mnemonic: [ begins
subscripts.)
As of Perl 5, assignment to ``$['' is treated as a compiler directive,
and cannot influence the behavior of any other file. Its use is
discouraged.
perl -v. It can be used to
determine at the beginning of a script whether the perl interpreter
executing the script is in the right range of versions. If used in a
numeric context, returns the version + patchlevel / 1000. Example:
# see if getc is available
($version,$patchlevel) =
$] =~ /(\d+\.\d+).*\nPatch level: (\d+)/;
print STDERR "(No filename completion available.)\n"
if $version * 1000 + $patchlevel < 2016;
or, used numerically,
warn "No checksumming!\n" if $] < 3.019;
(Mnemonic: Is this version of perl in the right bracket?)
open() fails. (Ordinary file descriptors are
closed before the open() is attempted.) Note that the close-on-exec
status of a file descriptor will be decided according to the value of
$^F at the time of the open, not the time of the exec.
undef to disable
inplace editing. (Mnemonic: value of -i switch.)
argv[0].
$#ARGV is the generally number of arguments minus
one, since $ARGV[0] is the first argument, NOT the command name. See
``$0'' for the command name.
do EXPR, require, or use constructs. 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.
do or require. The key is the filename you
specified, and the value is the location of the file actually found.
The require command uses this array to determine whether a given file
has already been included.
ENV changes the environment for child processes.
sub handler { # 1st argument is signal name
local($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
The %SIG array only contains values for the signals actually set within the Perl script. Here are some other examples:
$SIG{PIPE} = Plumber; # SCARY!!
$SIG{"PIPE"} = "Plumber"; # just fine, assumes main::Plumber
$SIG{"PIPE"} = \&Plumber; # just fine; assume current Plumber
$SIG{"PIPE"} = Plumber(); # oops, what did Plumber() return??
The one marked scary is problematic because it's a bareword, which means sometimes it's a string representing the function, and sometimes it's going to call the subroutine call right then and there! Best to be sure and quote it or take a reference to it. *Plumber works too. See perlsubs.
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.
| perlvar - Perl predefined variables |