my $array_reference = \@array;
[download]

print "COLOR: $$array_reference[3]\n";
[download]

foreach (@$reference) { print "IN THE SUB: $_\n"; }
[download]

For a good start on references and dereferencing see. tye's References quick reference and perlreftut.
HTH

_________
broquaint

Thank you to both of you for telling me how this works!

Then you make a reference to it using "\" called $array_reference.

Then you pass that reference to a subroutine print_array().

The subroutine dereferences the array (@$reference) and loops over the items in the array, printing them out.

Then you dereference the 4th item (starts at 0) with $$array_reference[3]. (you can also use $array_reference->[3] which I think looks nicer).

Comments posted to date are on target. It might help to conceptually break apart what you're doing when you mash together things like \@ or $$ or @$. Here's your example, using {} to break things up conceptually/visually:

#!/usr/bin/perl
use strict;

my @array = ('1','2','3','blue','red');

# Get an array reference (via "\@") for the array called "array"
my $array_reference = \@{array}; 

&print_array($array_reference);

# print 'blue'
# lookup the fourth array element "${X}[3]" of the X defined by $array
+_reference
print "COLOR: ${$array_reference}[3]\n";

sub print_array {
    my $reference = shift;
        # access as an array the thing defined by $reference
    foreach (@{$reference}) { print "IN THE SUB: $_\n"; }
}
[download]

The $$x and @$x are shortcuts to ${$x} and @{$x} -- in short, they tell perl how you want the reference to be interpreted -- either as a scalar or an array. The funny one might seem to be $$x[], but just as you access an element of @a with $a[], the array you could get via @{$x} you can access an element of with ${$x}[].

The tutorials suggested above are a good start for more detail

-xdg

Edited to fix display of [].

A reference is like a pointer from C and C++, except that it will always point at something (a reference can't be null or pointing to invalid memory).

So $array_reference is a variable which contains a pointer to the same memory as @array contains. That means that @array and @$array_reference (note the @ symbol there) are the same thing, but $array_reference (no @ symbol) is a different thing.

When the reference is passed to the sub, a copy of it is made. This copy also points to the same memory as @array, so @$reference is still the same thing as @array. If you tried to pass @array to the sub directly, the sub would have a copy of it and it would only be able to change the copy, but not be able to change the real @array.

You can read the tutorial for more information.

A reference can't be null but it can reference empty strings, null characters and undefined values.

#!/usr/bin/perl -w
use strict;

foreach my $ref (\'', \"\0", \undef) {
  print $ref, " --> ", ${$ref}, "\n";
}
[download]

Note the warning about using an uninitialized value.