Understanding Perl’s Special Variables

Perl comes with a whole bunch of cryptically-named built-in variables, which clever Perl programmers exploit to reduce the number of lines of code in their scripts. This article examines some of the more commonly-used special variable in Perl, with examples and illustrations of how they may be used.

You may find this hard to believe, but the Practical Extraction and Reporting Language, affectionately referred to as Perl by thousands of developers worldwide, was born primarily because its creator needed a tool to generate reports from raw text data. Over the years, though, Perl has grown from strength to strength; today, while it still boasts a very complete (and very impressive) text manipulation API, it can also be used to talk to databases, parse XML, execute SSL transactions and perform a wide variety of other (arcane?) functions.

Now, for newbie Perl programmers, one of the chief obstacles they have to overcome is the somewhat hard-to-understand shorthand used by experienced developers. This shorthand usually takes the form of built-in variables – my personal favourite is @_ though at one time I remember a particular fondness for $? – which have special meaning to the Perl interpreter and which, correctly used, can save you quite a few lines of code in your Perl program. Here, then, is a guide to the more interesting and commonly-used special variables in Perl, together with examples that demonstrate how they may be used.

{mospagebreak title=In Default}

One of the more important special variables you’ll encounter in your Perl forays is $_, which is used by many Perl functions and constructs as the so-called “default variable” when none other exists. In order to demonstrate, consider the following example:


#!/usr/bin/perl

# set array
%stuff = (“phone”, “Nokia”, “car”, “BMW”, “gun”, “Smith & Wesson”);

# iterate over array
foreach $s (keys(%stuff))
{
print “$sn”;
}

Here’s the output:


car
gun
phone

In this case, the foreach() loop iterates over the hash, assigning the key
at each iteration to the $s instance variable; this variable is then
printed with the print() function. If, however, you omit the instance
variable in the foreach() loop, Perl will assume that you want it to use
the default $_ variable as the instance variable.

The following example, which is equivalent to the one above, demonstrates:


#!/usr/bin/perl

# set array
%stuff = (“phone”, “Nokia”, “car”, “BMW”, “gun”, “Smith & Wesson”);

# iterate over array
foreach (keys(%stuff))
{
print “$_n”;
}

Here, every time the loop iterates over the hash, since no instance variable is specified, Perl will assign the key to the default variable $_. This variable can then be printed via a call to print().

The $_ variable also serves as the default for both chop() and print() functions. Going back to the example above, you could also write it this way,


#!/usr/bin/perl

# set array
%stuff = (“phone”, “Nokia”, “car”, “BMW”, “gun”, “Smith & Wesson”);

# iterate over array
foreach (keys(%stuff))
{
print;
}

which would return


cargunphone

The $_ variable is also the default variable used by file and input handles. For example, consider the following simple Perl script, which prints back whatever input you give it:


#!/usr/bin/perl

# read from standard input
# print it back
while (<STDIN>)
{
print $_;
}

In this case, every line read by the standard input is assigned to the $_ variable, which is then printed back out with print().

Knowing what you now know about print() and $_, it’s clear that you could also write the above as


#!/usr/bin/perl

# read from standard input
# print it back
while (<STDIN>)
{
print;
}

The $_ default variable is used in a number of different places: it is the default variable used for pattern-matching and substitution operations; the default variable used by functions like print(), chop(), grep(), ord(), etc; the default instance variable in foreach() loops; and the default used for various file tests.

{mospagebreak title=Input…}

Another very useful variable is the $/ variable, which Perl calls the input
record separator. The $/ variable contains one or more characters that
serve as line delimiters for Perl; Perl uses this variable to identify
where to break lines in a file.

In order to illustrate, consider the following sample password file:


shutdown:x:6:0:shutdown:/sbin:/sbin/shutdown
halt:x:7:0:halt:/sbin:/sbin/halt
mail:x:8:12:mail:/var/spool/mail:/sbin/nologin
news:x:9:13:news:/etc/news:
uucp:x:10:14:uucp:/var/spool/uucp:/sbin/nologin
operator:x:11:0:operator:/root:/sbin/nologin
games:x:12:100:games:/usr/games:/sbin/nologin
gopher:x:13:30:gopher:/var/gopher:/sbin/nologin
ftp:x:14:50:FTP User:/var/ftp:/sbin/nologin
nobody:x:99:99:Nobody:/:/sbin/nologin

By default, the $/ variable is set to the newline character. Therefore,
when Perl reads a file like the one above, it will use the newline
character to decide where each line ends – as illustrated in the following
example:


#!/usr/bin/perl

# read file into array
open (FILE, “dummy.txt”);
@lines = <FILE>;

# iterate over file and print each line
foreach $line (@lines)
{
print “— ” . $line;
}

# print number of lines in file
$count = @lines;
print “$count lines in file!n”;

Here’s the output:


— shutdown:x:6:0:shutdown:/sbin:/sbin/shutdown
— halt:x:7:0:halt:/sbin:/sbin/halt
— mail:x:8:12:mail:/var/spool/mail:/sbin/nologin
— news:x:9:13:news:/etc/news:
— uucp:x:10:14:uucp:/var/spool/uucp:/sbin/nologin
— operator:x:11:0:operator:/root:/sbin/nologin
— games:x:12:100:games:/usr/games:/sbin/nologin
— gopher:x:13:30:gopher:/var/gopher:/sbin/nologin
— ftp:x:14:50:FTP User:/var/ftp:/sbin/nologin
— nobody:x:99:99:Nobody:/:/sbin/nologin
10 lines in file!

Now, if you alter the input record separator, Perl will use a different
delimiter to identify where each line begins. Consider the following
example, which sets a colon (:) to be used as the delimiter, and its
output, which illustrates the difference:


#!/usr/bin/perl

# set input record separator
$/ = “:”;

# read file into array
open (FILE, “dummy.txt”);
@lines = <FILE>;

# iterate over file and print each line
foreach $line (@lines)
{
print “— ” . $line;
}

# print number of lines in file
$count = @lines;
print “$count lines in file!n”;

Here’s the new output:


— shutdown:— x:— 6:— 0:— shutdown:— /sbin:— /sbin/shutdown
halt:— x:— 7:— 0:— halt:— /sbin:— /sbin/halt
mail:— x:— 8:— 12:— mail:— /var/spool/mail:— /sbin/nologin
news:— x:— 9:— 13:— news:— /etc/news:—
uucp:— x:— 10:— 14:— uucp:— /var/spool/uucp:— /sbin/nologin
operator:— x:— 11:— 0:— operator:— /root:— /sbin/nologin
games:— x:— 12:— 100:— games:— /usr/games:— /sbin/nologin
gopher:— x:— 13:— 30:— gopher:— /var/gopher:— /sbin/nologin
ftp:— x:— 14:— 50:— FTP User:— /var/ftp:— /sbin/nologin
nobody:— x:— 99:— 99:— Nobody:— /:— /sbin/nologin
61 lines in file!

You can even undef() the record separator, which will result in Perl
reading the entire file into a single string. Take a look:


#!/usr/bin/perl

# remove input record separator
undef($/);

# read file into array
open (FILE, “dummy.txt”);
@lines = <FILE>;

# iterate over file and print each line
foreach $line (@lines)
{
print “— ” . $line;
}

# print number of lines in file
$count = @lines;
print “$count lines in file!n”;

And here’s the new output, which clearly displays that the file has been
read as a single line:


— shutdown:x:6:0:shutdown:/sbin:/sbin/shutdown
halt:x:7:0:halt:/sbin:/sbin/halt
mail:x:8:12:mail:/var/spool/mail:/sbin/nologin
news:x:9:13:news:/etc/news:
uucp:x:10:14:uucp:/var/spool/uucp:/sbin/nologin
operator:x:11:0:operator:/root:/sbin/nologin
games:x:12:100:games:/usr/games:/sbin/nologin
gopher:x:13:30:gopher:/var/gopher:/sbin/nologin
ftp:x:14:50:FTP User:/var/ftp:/sbin/nologin
nobody:x:99:99:Nobody:/:/sbin/nologin
1 lines in file!

{mospagebreak title=…And Output}

The reverse of the input record separator is the output record separator,
quite logically found in the $ variable. While the $/ variable deals with
the delimiter used by Perl to break input into discrete records, the $
variable controls which delimiter Perl uses to separate multiple print()
invocations.

By default, the output record separator is null, which means that the
output from every call to print() gets attached to the output from the
previous call. Consider the following example, which demonstrates:


#!/usr/bin/perl

# print output
print “The”;
print “cow”;
print “jumped”;
print “over”;
print “the”;
print “moon”;

Here’s the output:


Thecowjumpedoverthemoon

You can alter this by specifying a different value from the $ variable -
as the following example does:


#!/usr/bin/perl

# set output record separator
$ = ” -?- “;

# print output
print “The”;
print “cow”;
print “jumped”;
print “over”;
print “the”;
print “moon”;

Here’s the result:


The -?- cow -?- jumped -?- over -?- the -?- moon -?-

Similar, though not identical, is the output field separator, which is used
to specify the delimiter between the different values specified in a single
print() command. This value is stored in the $, variable, and is usually
null. Consider the following example, which demonstrates how it can be used:


#!/usr/bin/perl

# set output field separator
$, = “:”;

# print output
print “The”, “cow”, “jumped”, “over”, “the”, “moon”;

Here’s the output:


The:cow:jumped:over:the:moon

A common use of these two variables is to customize the output of the
print() command – as in the following example:


#!/usr/bin/perl

# load module
use DBI();

# connect
my $dbh = DBI->connect(“DBI:mysql:database=test;host=localhost”, “root”,
“secret”, {‘RaiseError’ => 1}) or die (“Cannot connect to database”);

# query
my $sth = $dbh->prepare(“SELECT name, age, sex FROM users”);
$sth->execute();

# set separators
$, = “:”;
$ = “rn”;

# print data as colon-separated fields
# each record separated by carriage return
while(my $ref = $sth->fetchrow_hashref())
{
print $ref->{‘name’}, $ref->{‘age’}, $ref->{‘sex’};
}

# clean up
$dbh->disconnect();

Here’s the output:


john:34:M
jimmy:21:M
john:31:F
jane:27:F

Sure, this is a very complicated way of doing something really simple – but
hey, it’s an example. Don’t take it too seriously!

{mospagebreak title=Getting Into An Argument}

Perl comes with some very interesting variables specifically designed to
store input arguments, for both scripts and subroutines. The first of these
is the special @ARGV array, which contains a list of all the command-line
arguments passed to the Perl program; each argument is indexed as an
element of the array. Consider the following example, which demonstrates:


#!/usr/bin/perl

# get length of argument list
$num = @ARGV;

# iterate and print arguments
for ($x=0; $x<$num; $x++)
{
print “Argument ” . ($x+1) . ” is $ARGV[$x]n”;
}

Here’s an example of the output (I called this script with the command-line
arguments “red 5px Arial”):


Argument 1 is red
Argument 2 is 5px
Argument 3 is Arial

Perl also comes with a variable named @_, which contains arguments passed
to a subroutine, and which is available to the subroutine when it is
invoked. The value of each element of the array can be accessed using
standard scalar notation – $_[0] for the first element, $_[1] for the
second element, and so on.

In order to illustrate, consider the following example:


#!/usr/bin/perl

# define a subroutine
sub add_two_numbers
{
$sum = $_[0] + $_[1];
return $sum;
}

$total = &add_two_numbers(3,5);
print “The sum of the numbers is $totaln”;

In the example above, once the &add_two_numbers subroutine is invoked with
the numbers 3 and 5, the numbers are transferred to the @_ variable, and
are then accessed using standard scalar notation within the subroutine.
Once the addition has been performed, the result is returned to the main
program, and displayed on the screen via the print() statement.

{mospagebreak title=The Right Path}

A number of other special array variables also exist, in addition to @ARGV.
One of the more commonly-used ones is the @INC variable, which sets up the
“include paths” that Perl will look in when it encounters a call to
require() or use(). This is analogous to the UNIX $PATH variable, which
sets up default search paths for system binaries.

Let’s take a look at this variable with the Data::Dumper module, used to
“stringify” Perl data structure.


#!/usr/bin/perl

# use data dumper
use Data::Dumper;

# examine data structure
print Dumper @INC;

Here’s what it looks like:


$VAR1 = ‘/usr/lib/perl5/5.8.0/i386-linux-thread-multi’;
$VAR2 = ‘/usr/lib/perl5/5.8.0′;
$VAR3 = ‘/usr/lib/perl5/site_perl/5.8.0/i386-linux-thread-multi’;
$VAR4 = ‘/usr/lib/perl5/site_perl/5.8.0′;
$VAR5 = ‘/usr/lib/perl5/site_perl’;
$VAR6 = ‘/usr/lib/perl5/vendor_perl/5.8.0/i386-linux-thread-multi’;
$VAR7 = ‘/usr/lib/perl5/vendor_perl/5.8.0′;
$VAR8 = ‘/usr/lib/perl5/vendor_perl’;
$VAR9 = ‘.’;

In case you need to add a new search path to this, it’s pretty simple -
take a look:


#!/usr/bin/perl

# use data dumper
use Data::Dumper;

# add new path to include
push(@INC, “/usr/local/myapp/includes/”);

# examine data structure
print Dumper @INC;

Here’s the result:


$VAR1 = ‘/usr/lib/perl5/5.8.0/i386-linux-thread-multi’;
$VAR2 = ‘/usr/lib/perl5/5.8.0′;
$VAR3 = ‘/usr/lib/perl5/site_perl/5.8.0/i386-linux-thread-multi’;
$VAR4 = ‘/usr/lib/perl5/site_perl/5.8.0′;
$VAR5 = ‘/usr/lib/perl5/site_perl’;
$VAR6 = ‘/usr/lib/perl5/vendor_perl/5.8.0/i386-linux-thread-multi’;
$VAR7 = ‘/usr/lib/perl5/vendor_perl/5.8.0′;
$VAR8 = ‘/usr/lib/perl5/vendor_perl’;
$VAR9 = ‘.’;
$VAR10 = ‘/usr/local/myapp/includes’;

There’s also a %INC hash, which lists all the files which have been
included by the current script, together with their paths.


#!/usr/bin/perl

# use data dumper
use Data::Dumper;

# examine data structure
print Dumper [%INC];

Here’s the output:


$VAR1 = [
{
'warnings.pm' => '/usr/lib/perl5/5.8.0/warnings.pm',
'warnings/register.pm' =>
'/usr/lib/perl5/5.8.0/warnings/register.pm',
'bytes.pm' => '/usr/lib/perl5/5.8.0/bytes.pm',
'Carp.pm' => '/usr/lib/perl5/5.8.0/Carp.pm',
'XSLoader.pm' =>
'/usr/lib/perl5/5.8.0/i386-linux-thread-multi/XSLoader.pm',
'overload.pm' => '/usr/lib/perl5/5.8.0/overload.pm',
'Exporter.pm' => '/usr/lib/perl5/5.8.0/Exporter.pm',
'Data/Dumper.pm' =>
'/usr/lib/perl5/5.8.0/i386-linux-thread-multi/Data/Dumper.pm'
}
];

The difference between @INC and %INC is subtle but important – the former
specifies the list of paths to search for files, while the latter specifies
the files which have already been included in the current script, together
with their paths.

There’s also the %ENV hash, which contains a list of available environment
variables.


#!/usr/bin/perl

# use data dumper
use Data::Dumper;

# examine data structure
print Dumper [%ENV];

Take a look (this is an abridged output sample):


$VAR1 = [
{
'HOME' => '/home/me',
'SSH_CLIENT' => '192.168.0.241 1099 22',
'LESSOPEN' => '|/usr/bin/lesspipe.sh %s',
'MAIL' => '/var/spool/mail/me',
'PWD' => '/home/me',
'LANG' => 'en_US',
'USER' => 'me',
'G_BROKEN_FILENAMES' => '1',
'TERM' => 'xterm',
'SSH_TTY' => '/dev/pts/5'
}
];

Since %ENV is a hash, it’s fairly easy to alter an environment setting -
all you have to do is specify a new value for the corresponding hash key.
Consider the following example, which shows you how:


#!/usr/bin/perl

# get value
print “Terminal is $ENV{‘TERM’}n”;;

# change value
$ENV{‘TERM’} = ‘vt100′;

# get new value
print “Terminal is now $ENV{‘TERM’}n”;;

Here’s the output:


Terminal is xterm
Terminal is now vt100

{mospagebreak title=To Err Is Human}

When it comes to dealing with errors, there are a number of variables you
should know about. The first of them is the $? variable, which stores the
error code returned by a call to an external binary, or to the system()
function.


#!/usr/bin/perl

# add a user who already exists
`/usr/sbin/useradd root 2>/dev/null`;

# if error code, return it
if ($?)
{
print “Error code “, $? >> 8;
}

Here’s the output:


Error code 9

In case you’re wondering about the bitwise operation in the program above -
the value stored in the $? variable is a 16-bit integer, of which the first
8 bits represent the error code returned by the invoked command.

You can also use the


$? & 127

operation to obtain information on the termination signal of the command, and


$? & 128

operation to get a Boolean value indicating whether or not the program
dumped core.

As you may (or may not) know, Perl also allows you to trap errors in a
syntax similar to Java’s try-catch() blocks, by enclosing your code in an
eval() block. In case the code within the eval() block produces an error,
Perl stores the error in the $@ system variable without escalating it to
the main program, from whence it may be retrieved for exception-handling
purposes. The following example illustrates:


#!/usr/bin/perl

# attempt to use a file which does not exist
eval( “use Timezone;” );

# check for error
if ($@ ne “”)
{
print “The following error occurred: “, $@;
}

In this case, since the call to use() is within an eval() block, the error
returned when Perl is unable to locate the Timezone package will be trapped
by the special $@ variable and will not be escalated upwards to the main
program. You can then write your own exception-handling routine to inspect
$@ and resolve the error appropriately.

Here’s the output, with the $@ error-trapping above in action:


The following error occurred: Can’t locate Timezone.pm in @INC (@INC
contains: /usr/lib/perl5/5.8.0/i386-linux-thread-multi .) at (eval 1) line 1.
BEGIN failed–compilation aborted at (eval 1) line 1.

You can also catch error messages returned by die() within an eval() block
with the $@ variable – as illustrated below:


#!/usr/bin/perl

# open file
eval( “open(FILE, ‘/tmp/dummy.txt’) or die (‘Could not open file’);”);

# check for error
if ($@ ne “”)
{
print “The following error occurred: “, $@;
}

Here’s the output:


The following error occurred: Could not open file at (eval 1) line 1.

In the case of Perl functions that use C library calls, you can also access
the error returned by the underlying C library with the special $!
variable. In order to illustrate, consider the Perl open() function, which
uses the C open() call, in a variant of the example above:


#!/usr/bin/perl

# open file
eval( “open(FILE, ‘/tmp/dummy.txt’) or die (‘Could not open file’);”);

# check for error
print “The following error occurred: $!”;

Note how, in this case, the error message displayed is the one returned by
the C library, not Perl (compare it with the previous example to see the
difference):


The following error occurred: No such file or directory

{mospagebreak title=A Question Of Ownership}

You can obtain information on the user and group the Perl script is running
as, with the following four variables:

$< – the real UID of the process

$> – the effective UID of the process

$) – the real GID of the process

$( – the effective GID of the process

A difference between “real” and “effective” IDs appears when you use the
setuid() or setgid() command to change the user or group. The “real” ID is
always the one prior to the setuid() or setgid() call; the “effective” one
is the one you’ve changed into following the call.

Consider the following example, which demonstrates:


#!/usr/bin/perl

# print real UID
print “Real UID: $<n”;

# print real GID
print “Real GID: $(n”;

# print effective UID
print “Effective UID: $>n”;

# print effective GID
print “Effective GID: $)n”;

Here’s the output:


Real UID: 515
Real GID: 100 514 501 100
Effective UID: 515
Effective GID: 100 514 501 100

Notice that the $) and $( commands return a list of all the groups the user
belongs to, not just the primary group.

Of course, most often this is not very useful by itself. What you really
need is a way to map the numeric IDs into actual user and group names. And
Perl comes with built-in functions to do this – consider the following
example, which illustrates:


#!/usr/bin/perl

# set record separator
$=” “;

# print user and group
print “This script is running as ” . getpwuid($>) . ” who belongs to the
following groups:”;

foreach (split(” “, $))) { print scalar(getgrgid($_)); };

Here’s the output:


This script is running as john who belongs to the following groups: users
software apps

{mospagebreak title=Rank And File}

When reading data from files, Perl allows you to obtain the name of the
file with the $ARGV variable, and the line number with the $. variable.
This makes it easy to obtain information on which file (and which line of
the file) is under the gun at any given moment. Consider the following
example, which demonstrates:


#!/usr/bin/perl

# read a file and print its contents
while (<>)
{
# for each line, print file name, line number and contents
print $ARGV, “,”, $., “: “;
print;
}

Here’s an example of the output:


multiply.pl,1: #!/usr/bin/perl
multiply.pl,2:
multiply.pl,3: # multiply two numbers
multiply.pl,4: sub multiply()
multiply.pl,5: {
multiply.pl,6: my ($a, $b) = @_;
multiply.pl,7: return $a * $b;
multiply.pl,8: }
multiply.pl,9:
multiply.pl,10: # set range for multiplication table
multiply.pl,11: @values = (1..10);
multiply.pl,12:
multiply.pl,13: # get number from command-line
multiply.pl,14: foreach $value (@values)
multiply.pl,15: {
multiply.pl,16: print “$ARGV[0] x $value = ” . &multiply($ARGV[0],
$value) . “n”;
multiply.pl,17: }

Note, however, that the line number returned by $. does not automatically
reset itself when used with multiple files, but rather keeps incrementing.
In order to have the variable reset to 0 every time a new file is opened,
you need to explicitly close() the previous file before opening a new one.

The $0 variable returns the file name of the currently-running Perl script,
as illustrated below:


#!/usr/bin/perl

# print filename
print “My name is $0″;

Here’s the output:


My name is /tmp/temperature.pl

The $$ variable returns the process ID of the currently-running Perl
process, as below:


#!/usr/bin/perl

# print process ID
print “This script is owned by process ID $$. Collect them all!”;

Here’s the output:


This script is owned by process ID 2209. Collect them all!

Finally, the special variable $] always contains information on the Perl
version you are currently running. So, for example, the program


#!/usr/bin/perl

# print Perl version
print “Running Perl $]”;

might return something like this:


Running Perl 5.008

This, coupled with the $0 and $$ variables explained earlier, can come in
handy when debugging misbehaving Perl programs,


#!/usr/bin/perl

# check for error
if ($error == 1)
{
# write to error log with script name, PID and Perl version
open (FILE, “>>/tmp/error.log”);
print FILE “Error in $0 (perl $] running as PID $$n”;
close (FILE);
}

or even to perform version checks to ensure that your code only works with
a specific Perl version.


#!/usr/bin/perl

# check version
# display appropriate message
if ($] < 5.0)
{
die(“You need a more recent version of Perl to run this program”);
}
else
{
print “This is Perl 5 or better”;
}

{mospagebreak title=Calling For A Translator}

Now, while the cryptic variable names discussed over the preceding pages
are frequently-used by experienced Perl developers. novice users might find
them a little disconcerting (at least in the beginning). That’s why Perl
also provides for alternative syntax, in the form of longer, more-readable
English-language equivalents for the variables discussed previously.

In order to use the more-readable human-language names, simply add the line


use English;

to the top of your Perl script.

You should now be able to use Perl’s longer names for the special variables
discussed in this tutorial, thereby adding greater readability to your
script. Here’s a list mapping the special variables discussed above to
their longer names:

$_ = $ARG

$/ = $INPUT_RECORD_SEPARATOR

$ = $OUTPUT_RECORD_SEPARATOR

$, = $OUTPUT_FIELD_SEPARATOR

$? = $CHILD_ERROR

$@ = $EVAL_ERROR

$! = $OS_ERROR

$< = $REAL_USER_ID

$> = $EFFECTIVE_USER_ID

$( = $REAL_GROUP_ID

$) = $EFFECTIVE_GROUP_ID

$. = $INPUT_LINE_NUMBER

$0 = $PROGRAM_NAME

$$ = $PROCESS_ID

$] = $PERL_VERSION

Consider the following variant of a previous example, which demonstrates
how they may be used:


#!/usr/bin/perl

use English;

# set record separator
$OUTPUT_RECORD_SEPARATOR=” “;

# print user and group
print “This script is running as ” . getpwuid($EUID) . ” who belongs to the
following groups:”;

foreach (split(” “, $))) { print scalar(getgrgid($ARG)); };

{mospagebreak title=End Zone}

And that’s about it for this tutorial. Over the preceding few pages, I
introduced you to the following special variables in Perl:

$_ (the default variable)

$/ (the input record separator)

$ (the output record separator)

$, (the output field separator)

@ARGV (the command-line argument array)

@_ (the subroutine argument array)

@INC (the include path array)

%ENV (the environment variable array)

$? and $! (the last error code)

$@ (the last error in an eval() block)

$<, $>, $) and $( (the real and effective UID/GIDs)

$. (the line number of an input file)

$ARGV (the name of an input file)

$0 (the name of the current script)

$$ (the process ID of the current script)

$[ (the Perl version number)

Of course, these are just some of the more commonly-used creatures you’ll
encounter in your travels through the Perl universe. Perl has a whole bunch
more of these special variables which have not been discussed here – you
can find them all in the “perlvar” manual page. Take a look for yourself,
and until we meet again…stay healthy!

Note: Examples are illustrative only, and are not meant for a production
environment. Melonfire provides no warranties or support for the source
code described in this article. YMMV!

Google+ Comments

Google+ Comments