Note: This is actually part one in a five part series, so if this goes over well, I can either append the other five parts or create them separately.

Understanding references and their subtleties in Perl is one of the more difficult concepts to fully wrap one's head around. However, once they are fully understood by the blossoming developer, they find a whole new level of capability and power to exploit and explore.

I often see newer programmers struggle with the concept of references on the Perl help sites I frequent. Some still have a ways to go, but many are at the stage where perhaps one more tutorial may push them over the edge and give them that 'Ahhhh' moment of clarity. My moment of clarity came when I read Randal Schwartz's "Learning Perl Objects, References & Modules" book for the something like the 8th time. Although once the concept of references is understood, the syntax and use cases can still be confusing for quite some time, especially in Perl, because There Is More Than One Way To Do It.

This tutorial will teach you the basics of Perl references, paving the way for more advanced aspects of their use.

This tutorial assumes that you have a very good understanding of the Perl variable types, when they are needed, and how they are used. Some exposure to references may also prove helpful, but shouldn't be required.

THE BASICS

References in Perl are nothing more than a scalar variable that instead of containing a usable value, they 'point' to a different variable. When you perform an action on a reference, you are actually performing the action on the variable that the reference points to. A Perl reference is similar to a shortcut to a file or program on your computer. When you double click the shortcut, the shortcut doesn't open, it's the file that the shortcut points to that does.

We'll start with arrays, and I'll get right into the code.

We'll define an array as normal, and then print out its contents.

my @array = ( 1, 2, 3 );

for my $elem ( @array ){
    say $elem;
}
[download]

Prepending the array with a backslash is how we take a reference to the array and assign the reference to a scalar. The scalar $aref now is a reference that points to @array.

my $aref = \@array;
[download]

At this point, if you tried to print out the contents of $aref, you would get the location of the array being pointed to. You know you have a reference if you ever try to print a scalar and you get output like the following:

ARRAY(0x9bfa8c8)
[download]

Before we can use the array the reference points to, we must dereference the reference. To gain access to the array and use it as normal, we use the array dereference operator @{}. Put the array reference inside of the dereference braces and we can use the reference just as if it was the array itself:

for my $elem ( @{ $aref } ){
    say $elem;
}
[download]

The standard way of assigning an individual array element to a scalar:

my $x  = $array[0];
[download]

To access individual elements of the array through the reference, we use a different dereference operator:

my $y = $aref->[1];
[download]

Assign a string to the second element of the array in traditional fashion:

$array[1]  = "assigning to array element 2";
[download]

To do the same thing through an array reference, we dereference it the same way we did when we were taking an element from the array through the reference:

$aref->[1] = "assigning to array element 2";
[download]

You just learnt how take a reference to an array (by prepending the array with a backslash), how to dereference the entire array reference by inserting the reference within the dereference block @{}, and how to dereference individual elements of the array through the reference with the -> dereference operator. That is all there is to it. Hashes are extremely similar. Let's look at them now.

Create and initialize a normal hash, and iterate over its contents:

my %hash = ( a => 1, b => 2, c => 3 );

while ( my ( $key, $value ) = each %hash ){

    say "key: $key, value: $value";
}
[download]

Take a reference to the hash, and assign it to a scalar variable:

my $href = \%hash;
[download]

Now we'll iterate over the hash through the reference. To access the hash, we must dereference it just like we did the array reference above. The dereference operator for a hash reference is %{}. Again, just wrap the reference within its dereferencing block:

while ( my ( $key, $value ) = each %{ $href } ){

    say "key: $key, value: $value";
}
[download]

Access an individual hash value:

my $x = $hash{ a };
[download]

Access an individual hash value through the reference. The dereference operator for accessing individual elements of a hash through a reference is the same one we used for an array (->).

my $y = $href->{ a };
[download]

Assign a value to hash key 'a':

$hash{ a }  = "assigning to hash key a";
[download]

Assign a value to hash key 'a' through the reference:

$href->{ a } = "assigning to hash key a";
[download]

That's essentially the basics of taking a reference to something, and then dereferencing the reference to access the data it points to.

When we operate on a reference, we are essentially operating on the item being pointed to directly. Here is an example that shows, in action, how operating directly on the item has the same effect as operating on the item through the reference.

my @array = ( 1, 2, 3 );
my $aref = \@array;

# assign a new value to $b[0] through the reference

$aref->[0] = 99;

# print the array

for my $elem ( @array ){
    say $elem;
}
[download]

Output:

99
2
3
[download]

As you can see, the following two lines are equivalent:

$array[0] = 99;
$aref->[0] = 99;
[download]

CHEAT SHEET

Here's a little cheat sheet for review before we move on to the next part in the series.

my @array = ( 1, 2, 3 );
my %hash  = ( a => 1, b => 2, c => 3 );

# take a reference to the array
my $aref = \@array;

# take a reference to the hash
my $href = \%hash;

# access the entire array through its reference
my $elem_count = scalar @{ $aref };

# access the entire hash through its reference
my $keys_count = keys %{ $href };

# get a single element through the array reference
my $element = $aref->[0];

# get a single value through the hash reference
my $value = $href->{ a };

# assign to a single array element through its reference
$aref->[0] = 1;

# assign a value to a single hash key through its ref
$href->{ a } = 1;
[download]

if you want to see where I'm going with this and you feel it ok as a tutorial, you can find the other parts of this series here that I would somehow blend in.