Perl Predefined Variables

Variable Description Example

The default input and pattern-searching space.
$ARG while (<>) {...} #equiv. only in while
(Mnemonic: underline is understood in certain while (defined($_ = <>)) {...}
$_ operations.)
$a Special package variables when using sort(), see @articles = sort {$a cmp $b} @files;
$b sort.
Contains the sub-pattern from the corresponding
$<digits> set of capturing parentheses from the last pattern
match. (Mnemonic: like \digits.)
$MATCH The string matched by the last successful pattern
$& match. (Mnemonic: like & in some editors.)
The string preceding whatever was matched by the local $_ = 'abcdefghi';
$PREMATCH
last successful pattern match. (Mnemonic: ` often /def/;
$` print "$` : $& : $'", "\n";
precedes a quoted string.)
# prints abc : def : ghi
The string following whatever was matched by the
$POSTMATCH
last successful pattern match. (Mnemonic: ' often
$’
follows a quoted string.)
The text matched by the last bracket of the last
$LAST_PATTERN successful search pattern. /Version: (.*)|Revision: (.*)/
_MATCH This is useful if you don't know which one of a set &&
$+ of alternative patterns matched. (Mnemonic: be ($rev = $+);
positive and forward looking.)
The text matched by the used group most-recently
closed (i.e. the group with the rightmost closing $v = "sep:2:match";
$^N parenthesis) of the last successful search pattern. $v =~ /(?:(\d)(?{ $a = $^N }))/;
(Mnemonic: the (possibly) Nested parenthesis that print $a; # prints 2
most recently closed.)
$+[0] is the offset into the string of
the end of the entire match.
This array holds the offsets of the ends of the last $+[1] is the offset past where $1
@LAST_MATCH_END
successful submatches in the currently active ends.
@+ You can use $#+ to determine how many
dynamic scope.
subgroups were in the last successful
match.
Set to a non-zero integer value to do multi-line
matching within a string, 0 (or undefined) to tell Use of $* is deprecated in modern
$* Perl that it can assume that strings contain a single Perl, supplanted by the /s and /m
line, for the purpose of optimizing pattern modifiers on pattern matching.
matches. (Mnemonic: * matches multiple things.)
HANDLE->
input_line_number(EXPR) Current line number for the last filehandle
$INPUT_LINE_NUMBER accessed. (Mnemonic: many programs use "." to
$NR mean the current line number.)
$.
IO::Handle-> The input record separator, newline by default.
input_record_separator Setting $/ to a reference to an integer, scalar
(EXPR) containing an integer, or scalar that's convertible to
local $/; # enable "slurp" mode
$INPUT_RECORD an integer will attempt to read records instead of local $_ = <FH>; # whole file now here
_SEPARATOR lines, with the maximum record size being the
$RS referenced integer. (Mnemonic: / delimits line
$/ boundaries when quoting poetry.)
HANDLE-> If set to nonzero, forces a flush right away and
autoflush(EXPR) after every write or print on the currently selected
$OUTPUT_AUTOFLUSH output channel. Default is 0. (Mnemonic: when
$| you want your pipes to be piping hot.)
IO::Handle->
output_field_separator The output field separator for the print operator. If
(EXPR) defined, this value is printed between each of @arr = (1,2,3);
$OUTPUT_FIELD print's arguments. Default is undef. (Mnemonic: $, = “ - ”
_SEPARATOR what is printed when there is a "," in your print print @arr; # prints 1 – 2 - 3
$OFS statement.)
$,
IO::Handle->
output_record_separator
The output record separator for the print operator. @arr = (1, 2, “baz”);
(EXPR)
Default is undef. $\ = “\t”
$OUTPUT_RECORD foreach (@arr) { print }
(Mnemonic: you set $\ instead of adding "\n" at
_SEPARATOR the end of the print.) # prints 1 [tab] 2 [tab] baz
$ORS
$\

© 2007 Peteris Krumins [email protected] http://www.catonmat.net good coders code, great reuse
 This is like $, except that it applies to array and
@arr = (“foo”, “esr”, “rms”);
$LIST_SEPARATOR slice values interpolated into a double-quoted $” = “ - ”
$" string (or similar interpreted string). Default is a print “@arr”; # prints foo – esr – rms
space.
The subscript separator for multidimensional array
$SUBSCRIPT_SEPARATOR If you refer to a hash element as
emulation. Default is "\034", the same as SUBSEP
$SUBSEP $foo{$a,$b,$c} it really means
in awk. (Mnemonic: comma (the syntactic $foo{join($;, $a, $b, $c)}
$; subscript separator) is a semi-semicolon.)
The output format for printed numbers. This
variable is a half-hearted attempt to emulate awk's
OFMT variable. The initial value is "%.ng", where
$#
n is the value of the macro DBL_DIG from your
system's float.h. (Mnemonic: # is the number
sign.)
HANDLE->
format_page_number The current page number of the currently selected
(EXPR) output channel. Used with formats. (Mnemonic: %
$FORMAT_PAGE_NUMBER is page number in nroff.)
$%
HANDLE->
format_lines_per_page The current page length (printable lines) of the
(EXPR) currently selected output channel. Default is 60.
$FORMAT_LINES_PER_PA Used with formats. (Mnemonic: = has horizontal
GE lines.)
$=
HANDLE-> The number of lines left on the page of the
format_lines_left(EXPR) currently selected output channel. Used with
$FORMAT_LINES_LEFT formats. (Mnemonic: lines_on_page -
$- lines_printed.)
$` is same as substr($var, 0, $-[0])
$& is the same as substr($var, $-[0],
$+[0] - $-[0])
$-[0] is the offset of the start of the last successful $' is the same as substr($var, $+[0])
@LAST_MATCH_START match. $-[n] is the offset of the start of the $1 is the same as substr($var, $-[1],
@- substring matched by n-th subpattern, or undef if $+[1] - $-[1])
the subpattern did not match. $2 is the same as substr($var, $-[2],
$+[2] - $-[2])
$3 is the same as substr($var, $-[3],
$+[3] - $-[3])
HANDLE-> The name of the current report format for the
format_name(EXPR) currently selected output channel. Default is the
$FORMAT_NAME name of the filehandle.
$~ (Mnemonic: brother to $^ .)
HANDLE-> The name of the current top-of-page format for the
format_top_name(EXPR) currently selected output channel. Default is the
$FORMAT_TOP_NAME name of the filehandle with _TOP appended.
$^ (Mnemonic: points to top of page.)
IO::Handle->
The current set of characters after which a string
format_line_break
may be broken to fill continuation fields (starting
_characters(EXPR)
with ^) in a format. Default is " \n-", to break on
$FORMAT_LINE_BREAK whitespace or hyphens. (Mnemonic: a "colon" in
_CHARACTERS poetry is a part of a line.)
$:
IO::Handle->
format_formfeed(EXPR)
What formats output as a form feed. Default is \f.
$FORMAT_FORMFEED
$^L
The current value of the write() accumulator for
format() lines. A format contains formline() calls
that put their result into $^A . After calling its
$ACCUMULATOR
format, write() prints out the contents of $^A and
$^A
empties. So you never really see the contents of
$^A unless you call formline() yourself and then
look at it.
The exit value of the subprocess is
The status returned by the last pipe close, backtick really ($?>>8), and $? & 127 gives
$CHILD_ERROR
(`` ) command, successful call to wait() or which signal, if any, the process died
$? from, and $? & 128 reports whether
waitpid(), or from the system() operator.
there was a core dump.
The object reference to the Encode object that is
${^ENCODING} used to convert the source code to Unicode.
Default is undef.

© 2007 Peteris Krumins [email protected] http://www.catonmat.net good coders code, great reuse
 if (open(FH, $filename)) {
# Here $! is meaningless.
If used numerically, yields the current value of the ...
$OS_ERROR
C errno variable, or in other words, if a system or } else {
$ERRNO # ONLY here is $! meaningful.
library call fails, it sets this variable. (Mnemonic:
$! What just went bang?) ...
# Here $! might be meaningless.
}
For example, $!{ENOENT} is true if and
Each element of %! has a true value only if $! is only if the current value of $! is
%! ENOENT ; that is, if the most recent
set to that value.
error was "No such file or directory"
$EXTENDED_OS_ERROR Error information specific to the current operating
$^E system. (Mnemonic: Extra error explanation.)
The Perl syntax error message from the last eval()
$EVAL_ERROR
operator. (Mnemonic: Where was the syntax error
$@ "at"?)
$PROCESS_ID
The process number of the Perl running this script.
$PID
(Mnemonic: same as shells.)
$$
$REAL_USER_ID
The real uid of this process. (Mnemonic: it's the
$UID
uid you came from, if you're running setuid.)
$<
$< = $>; # set real to effective uid
$EFFECTIVE_USER_ID # swap real and effective uid
The effective uid of this process. (Mnemonic: it's
$EUID ($<,$>) = ($>,$<);
the uid you went to, if you're running setuid.)
$>

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

machine that supports membership in multiple The first number is the one returned
$REAL_GROUP_ID
groups simultaneously, gives a space separated list by getgid(), and the subsequent ones
$GID by getgroups(), one of which may be
of groups you are in. (Mnemonic: parentheses are
$( used to group things. The real gid is the group you the same as the first number.
left, if you're running setgid.)
The effective gid of this process. If you are on a
machine that supports membership in multiple
$EFFECTIVE_GROUP_ID
groups simultaneously, gives a space separated list
$EGID $) = "5 5"
of groups you are in. (Mnemonic: parentheses are
$) used to group things. The effective gid is the group
that's right for you, if you're running setgid.)
$PROGRAM_NAME Contains the name of the program being executed.
$0 (Mnemonic: same as sh and ksh.)
The index of the first element in an array, and of
$[ the first character in a substring. Default is 0.
(Mnemonic: [ begins subscripts.)
The version + patchlevel / 1000 of the Perl
$] interpreter. (Mnemonic: Is this version of perl in
the right bracket?)
$COMPILING The current value of the flag associated with the -c
$^C switch.
$DEBUGGING The current value of the debugging flags.
$^D (Mnemonic: value of -D switch.)
$SYSTEM_FD_MAX
The maximum system file descriptor, ordinarily 2.
$^F
WARNING: This variable is strictly for
This variable contains compile-time hints for the internal use only. Its availability,
$^H behavior, and contents are subject to
Perl interpreter.
change without notice.
WARNING: This variable is strictly for
The %^H hash provides the same scoping
internal use only. Its availability,
%^H semantic as $^H. This makes it useful for behavior, and contents are subject to
implementation of lexically scoped pragmas. change without notice.
The current value of the inplace-edit extension.
$INPLACE_EDIT
Use undef to disable inplace editing. (Mnemonic:
$^I
value of -i switch.)
By default, running out of memory is an # allocate a 64K buffer for use in
untrappable, fatal error. However, if suitably built, # an emergency if Perl was compiled
$^M # with -DPERL_EMERGENCY_SBRK
Perl can use the contents of $^M as an emergency
memory pool after die()ing. $^M = 'a' x (1 << 16);
The name of the operating system under which
$OSNAME
this copy of Perl was built, as determined during
$^O the configuration process.
An internal variable used by PerlIO. A string in
${^OPEN} two parts, separated by a \0 byte, 1st part describes
input layers, 2nd part descrabe output layers.
$PERLDB
The internal variable for debugging support.
$^P
$LAST_REGEXP_CODE The result of evaluation of the last successful (?{
_RESULT code }) regular expression assertion (see perlre).
$^R May be written to.
$^S State
$EXCEPTIONS_BEING --------- -------------------
_CAUGHT Current state of the interpreter. undef Parsing module/eval
$^S true (1) Executing an eval
false (0) Otherwise
The time at which the program began running, in
$BASETIME seconds since the epoch (beginning of 1970). The
$^T values returned by the -M, -A, and -C filetests are
based on this value.
Reflects if taint mode is on or off. 1 for on (the
${^TAINT} program was run with -T), 0 for off, -1 when only
taint warnings are enabled (i.e. with -t or -TU).
${^UNICODE} Reflects certain Unicode settings of Perl.
This variable indicates whether an UTF-8 locale
${^UTF8LOCALE}
was detected by perl at startup.
The revision, version, and subversion of the Perl
$PERL_VERSION
interpreter, represented as a string composed of
$^V
characters with those ordinals.
The current value of the warning switch, initially
$WARNING
true if -w was used, false otherwise, but directly
$^W modifiable. (Mnemonic: related to the -w switch.)
The current set of warning checks enabled by the
${^WARNING_BITS}
use warnings pragma.
The name used to execute the current copy of Perl,
$EXECUTABLE_NAME
from C's argv[0] or (where supported)
$^X
/proc/self/exe.
The special filehandle that iterates over command-
ARGV line filenames in @ARGV. Usually written as the
null filehandle in the angle operator <>
Contains the name of the current file when reading
$ARGV
from <>.
The array @ARGV contains the command-line
arguments intended for the script. $#ARGV is
@ARGV generally the number of arguments minus one,
because $ARGV[0] is the first argument, not the
program's command name itself.
The special filehandle that points to the currently
open output file when doing edit-in-place
ARGVOUT processing with -i. Useful when you have to do a
lot of inserting and don't want to keep modifying
$_.
The array @F contains the fields of each line read
@F in when autosplit mode is turned on. See perlrun
for the -a switch.
The array @INC contains the list of places that the
do EXPR , require, or use constructs look for their
@INC library files. It initially consists of the arguments
to any -I command-line switches, followed by the
default Perl library.
Within a subroutine the array @_ contains the
@_ parameters passed to that subroutine.
The hash %INC contains entries for each
%INC filename included via the do, require, or use
operators.
The hash %ENV contains your current
%ENV environment. Setting a value in ENV changes the
$ENV{expr} environment for any child processes you
subsequently fork() off.
sub handler {
# 1st argument is signal name
my($sig) = @_;
print "Caught a SIG$sig\n";
close(LOG);
exit(0);
%SIG The hash %SIG contains signal handlers for }
$SIG{expr} signals. $SIG{'INT'} = \&handler;
$SIG{'QUIT'} = \&handler;
# restore default action
$SIG{'INT'} = 'DEFAULT';
# ignore SIGQUIT
$SIG{'QUIT'} = 'IGNORE';

© 2007 Peteris Krumins [email protected] http://www.catonmat.net good coders code, great reuse