As you will recall, an array is just a container for a list. To assign a reference to that array to a scalar, prepend it with a backslash:

my @fools = qw(jester clown motley);
my $fools = \@fools;

The $fools variable now contains a reference to the @fools array. You can copy it to another array by prepending it with the @ sign (the array sigil).

my @copy_of_fools = @$fools;

To access individual elements of the $fools array reference, you use the same syntax as you would to access the original array, but you use the dereferecing operator, ->, between the array name and the square brackets. The following prints jester - motley.

my @fools      = qw(jester clown motley);
my $aref       = \@fools;
my $first_fool = $aref->[0];
my $last_fool  = $aref->[2];
print "$first_fool - $last_fool";

my $fools = \@fools;

Naturally, you can iterate over an array reference just like you would an array:

foreach my $fool ( @$aref ) {
    print "$fool\n";
}

And if you need to iterate over the indexes, you use the relatively obscure $# syntax in front of the array reference. The following code does the same thing as the previous code;

my @fools = qw(jester clown motley);
my $fools = \@fools;
foreach my $i ( 0 .. $#$fools ) {
    my $fool = $fools->[$i];
    print "$fool\n";
}

Though your author generally does not recommend the following (it can be confusing), be aware that you can dereference the value and interpolate it into a string just as you would a regular scalar:

foreach my $i ( 0 .. $#$fools ) {
    print "$fools->[$i]\n";
}

You take a reference to a hash the same way you take a reference to an array. Like an array reference, you access individual elements using the dereference operator after the variable name.

my %words = (
    dog   => 'chien',
    eat   => 'manger',
    clown => 'clown',
);
my $english_to_french = \%words;
my %copy = %$english_to_french;
my $eat = $english_to_french->{eat};
while ( my ( $english, $french ) = each %$english_to_french ) {
    print "The french word for '$english' is '$french'\n";
}

The previous code snippet should print something like this:

The french word for 'eat' is 'manger'
The french word for 'clown' is 'clown'
The french word for 'dog' is 'chien'

$foo->[7];
$$foo[7];                 # same thing
${$foo}[7];               # same thing
$word_for->{laughter};
$$word_for{laughter};     # same thing
${$word_for}{laughter};   # same thing

Anonymous references are commonly used to create rich data structures in Perl. They seem strange at first, but they’re very easy to use.

When you access an individual array or hash element, you wrap the index value in [] or {} respectively. Those braces are also used to construct anonymous hashes and arrays:

my $stuff  = [ 'foo', 'bar', 'baz' ];
my $colors = { red => '#FF0000', green => '#00FF00', blue => '#0000FF' };

However, it doesn’t make much sense to construct an anonymous array or hash and assign it directly to a scalar just so you can dereference it again. Instead, they are powerful when you use them inside of other data structures.

my @results = (
    [ 12, 19, 4      ],
    [ 454, 2, 42     ],
    [ 6,   9, 13, 44 ],
);

my $aref1 = $results[0];
my $aref2 = $results[1];
my $aref3 = $results[2];

my $number = $aref2->[2];

my @results = (
    [ 12, 19, 4      ],
    [ 454, 2, 42     ],
    [ 6,   9, 13, 44 ],
);
my $number = $results[1]->[2]; # number is now 42
my $results = \@results;

my $number = $aoaoa[3]->[1]->[0];

my $number = $aoaoa[3]->[1]->[0];
my $number = $aoaoa[3][1][0];      # same thing

push @$array, $value;

push @{ $some_array[3][0] }, $some_value;

Anonymous hashes

Anonymous hashes work the same way, but we use curly braces instead of square brackets. Here’s a hash of hashes (HoH), but we’ll make the top-level hash an anonymous hash assigned to a scalar.

my $sales = {
    monday    => { jim => 2, mary => 1 },
    tuesday   => { jim => 3, mary => 5 },
    wednesday => { jim => 7, mary => 3 },
    thursday  => { jim => 4, mary => 5 },
    friday    => { jim => 1, mary => 2 },
};

As you might expect, these are easier to read. What are Mary’s sales for Friday?

my $num_sales = $sales->{friday}{mary};

Note that you must use the dereference operator on the first element, but subsequent elements no longer require said dereferencing. Of course, you can use the dereference operator multiple times, if you prefer:

my $num_sales = $sales->{friday}->{mary};

Mixing and matching anonymous data structures allows you to create powerful data structures. Example 6.1, “Working with data structures” is smaller version of the previously shown $sales data structure, but instead of showing the number of sales for Jim and Mary, we provide anonymous array references showing the commission per sale.

Example 6.1. Working with data structures

use strict;
use warnings;
use diagnostics;
my $sales = {
    monday  => {
        jim  => [ 3, 4 ],
        mary => [ 4 ],
    },
    tuesday => {
        jim  => [ 3, 5, 1 ],
        mary => [ 1, 1, 1, 1, 9 ],
    },
};
my $commissions = $sales->{tuesday}{jim};
my $num_sales   = @$commissions;
my $total = 0;
foreach (@$commissions) {
    $total += $_;
}
print "Jim made $num_sales sales on Tuesday and earned \$$total commission\n";

Note

sales.pl available for download at Wrox.com.

That tells us that Jim isn’t earning a lot of money.

Jim made 3 sales on Tuesday and earned $9 commission

We escaped the first dollar sign on $total to tell Perl that we should not interpolate it that dollar sign as part of a variable, but merely print it.

As with arrays, data manipulation builtins behave as normal, so long as you dereference the item first.

my @days_of_the_week = keys %$sales;
my @sales_people     = keys %{ $sales->{monday} };

Arrays and hashes are the two most common types of references, but there are a variety of other references that can prove useful from time to time. The most popular is a subroutine reference. The following prints the number 9.

my $add_two = sub {
    my $number = shift;
    return $number + 2;
};
print $add_two->(7);

Don’t worry about how that works for now. We’ll be covering subroutine references more in Chapter 7, Subroutines, but we include it here for completeness.

Naturally, we can take a reference to a scalar. The following prints Ovid.

my $name = 'Ovid';
my $ref  = \$name;
print $$ref;

Scalar references might seem odd, but they do have uses at times.

Try it out Walking complex data structures

Example 6.1

We haven’t had many pages, but we’ve covered a lot of ground. Let’s walk through a compound data structure to make a simple report. We want to print a report showing the top sales person per day.

1. Save the following code as complex.pl

   use strict;
   use warnings;
   use diagnostics;
   my @day_of_week = qw(
     monday
     tuesday
     wednesday
     thursday
     friday
   );
   my @sales = (
       { jim   => 2, john      => 7, mary  => 1 },
       { alice => 4, jim       => 3, mary  => 5 },
       { jim   => 7, mary      => 3, pablo => 10 },
       { jim   => 4, mary      => 5 },
       { jim   => 1, katherine => 4, mary  => 2 },
   );
   print "Top sales per day report\n\n";
   printf "%10s   %10s  %s\n", 'Weekday', 'Person', 'Num sales';
   # get the name of the day and sales for that day
   foreach my $i ( 0 .. $#day_of_week ) {
       my $day         = ucfirst $day_of_week[$i];
       my $daily_sales = $sales[$i];
       # find top salesperson for the current day
       my $top_sales = 0;
       my $top_person;
       while ( my ( $salesperson, $num_sales ) = each %$daily_sales ) {
           if ( $num_sales > $top_sales ) {
               $top_sales  = $num_sales;
               $top_person = $salesperson;
           }
       }
       printf "%10s:  %10s  %-3d\n", $day, $top_person, $top_sales;
   }

   Note

   complex.pl available for download at Wrox.com.

2. Run the code with perl complex.pl and if you’ve copied it correctly, it should output the following:

   Top sales per day report
      Weekday       Person  Num sales
       Monday:        john  7
      Tuesday:        mary  5
    Wednesday:       pablo  10
     Thursday:        mary  5
       Friday:   katherine  4

How it works

All things considered, this is actually a fairly simple data structure (they’re so easy in Perl that people often create far more complicated ones), but let’s look at the top two arrays.

my @day_of_week = qw(
  monday
  tuesday
  wednesday
  thursday
  friday
);
my @sales = (
    { jim   => 2, john      => 7, mary  => 1 },
    { alice => 4, jim       => 3, mary  => 5 },
    { jim   => 7, mary      => 3, pablo => 10 },
    { jim   => 4, mary      => 5 },
    { jim   => 1, katherine => 4, mary  => 2 },
);

There are many ways we could have written this example, but in this case, we assume that the @sales in the second array are for Monday, Tuesday, Wednesday, Thursday and Friday. Each entry in @sales is a hashref with the first name of the salesperson as the key and the number of sales as the value.

The next two lines print out the top of our report:

print "Top sales per day report\n\n";
printf "%10s   %10s  %s\n", 'Weekday', 'Person', 'Num sales';

The printf() formats were carefully chosen to match the printf() formats for each day’s entry on the report.

Now we have a strange bit at the top of the for loop:

# get the name of the day and sales for that day
foreach my $i ( 0 .. $#day_of_week ) {
    my $day         = ucfirst $day_of_week[$i];
    my $daily_sales = $sales[$i];

The reason we’re using the $i variable and assigning values from 0 to $#day_of_week (remember, that’s the value of the last index in that array) is that by using this index, we can fetch the name of the day from @day_of_week and fetch the daily sales in the @sales array.

Next, we use a while loop to iterates over the $daily_sales hash reference.

# find top salesperson for the current day
    my $top_sales = 0;
    my $top_person;
    while ( my ( $salesperson, $num_sales ) = each %$daily_sales ) {
        if ( $num_sales > $top_sales ) {
            $top_sales  = $num_sales;
            $top_person = $salesperson;
        }
    }
    printf "%10s:  %10s  %-3d\n", $day, $top_person, $top_sales;
}

We simply keep track of the highest sale for that day and the name of the sales person associated with it. At the end of the while loop, we print that information out.

Of course, there are plenty of different ways we could have written the above code. It’s also not very robust. What if more than one salesperson made the same number of sales? What if the length of the @day_of_week and @sales arrays did not match? We’ll cover problems like this in Chapter 7, Subroutines when we discuss subroutines.

In the first Try It Out in this chapter, you saw how to work with references and even print them out. However, sometimes they’re a bit confusing and you’re not sure what you have. For example. let’s say you have the following line as line 23 of your program:

print $aref->[0]{sales};

And your program dies with the error message:

Not a HASH reference at some_program.pl line 23.

Now you want to know what you really have in the $aref variable.

One way to handle this is to just print $aref->[0]. In this case, it might print something like ARRAY(0xc51220). When you print a reference, you see the type of reference (an ARRAY in this case) followed by its hexadecimal address in memory.

Another way of dealing with this is the ref() function:

print ref $aref->[0];

For something that is not a reference, ref() returns the empty string. Here’s a handy little program that shows various reference types. You won’t understand all of these yet, but that’s OK. When you’re done with the book, this will be clear.

use strict;
use warnings;
my $foo;
sub handler {}
my $scalar    = ref $foo;
my $scalarref = ref \$foo;
my $arrayref  = ref \@ARGV;
my $hashref   = ref \%ENV;
my $coderef   = ref \&handler;
my $globref   = ref \*foo;
my $regexref  = ref qr//;
my $objectref = ref CGI->new;
print <<"END_REFERENCES";
Scalar:      $scalar
Scalar ref:  $scalarref
Array ref:   $arrayref
Hash ref:    $hashref
Code ref:    $coderef
Glob ref:    $globref
Regex ref:   $regexref
Object ref:  $objectref
END_REFERENCES

And that will print:

Name "main::foo" used only once: possible typo at /var/tmp/eval_CqOi.pl line 10.
Scalar:
Scalar ref:  SCALAR
Array ref:   ARRAY
Hash ref:    HASH
Code ref:    CODE
Glob ref:    GLOB
Regex ref:   Regexp
Object ref:  CGI

You see nothing printed for $scalar because ref() returns the empty string if called with an argument that is not a reference. The strange main::foo warning is because we’ve take the reference to something called a typeglob. We won’t cover them much in this book, but you can read perldoc perldata for more information if you’re curious.

The rest of the names should be straightforward, even though we’ve not covered all of the types yet. Globs will be covered (slighty) in Chapter 9, Files and Directories and regular expressions (the $regexref) will be covered in Chapter 8, Regular Expressions. Calling ref() on an object (Chapter 12, Object Oriented Perl) merely returns the name of the object’s class.

For large data structures, you might find it very frustrating to keep printing individual elements to find out what they are. This is where the very useful Data::Dumper module comes in handy. Data::Dumper has been shipped with Perl ever since version 5.005 (released July 1998).

You can add the following before the offending line to see what you have:

use Data::Dumper;
print Dumper($aref);

That might print out something like this:

$VAR1 = [
          [
            1,
            3
          ],
          [
            2,
            5
          ]
        ];

As you can see by reading this data structure, we have an array ref of array refs, not an array ref of hashrefs. Data::Dumper is an invaluable debugging tool when trying to figure out just what went wrong with your code. See perldoc Data::Dumper to understand how to customize its output.

Note that if you want to print out the values of arrays and hashes which are not references, you must pass them by reference to Data::Dumper and your output may look confused.

use Data::Dumper;
my @words = qw( this that other );
print Dumper(@words);
That prints out:
$VAR1 = 'this';
$VAR2 = 'that';
$VAR3 = 'other';

However, when you pass the array by reference, you get a cleaner output, so long as you understand references.

print Dumper(\@words);
$VAR1 = [
          'this',
          'that',
          'other'
        ];

Sometimes you need to copy a data structure. Ordinarily you can copy a variable like this:

my $x = 3;
my $y = $x;
$y    = 4;
print "$x - $y";

That prints 3 - 4. This is because the assignment operator copies the value from one expression to a variable (or variables). However, what happens when that value is a reference?

use Data::Dumper;
my $aref1   = [ 1, 3, 7 ];
my $aref2   = $aref1;
$aref2->[0] = 9;
print Dumper($aref1, $aref2);

That prints:

$VAR1 = [
          9,
          3,
          7
        ];
$VAR2 = $VAR1;

But how can the two variables be the same? We only changed the first value of the second array reference.

That’s because when we did $aref2 = $aref1, we assigned the reference of the first array ref to the second array ref. In Perl, this is automatically a shallow copy. A shallow copy only copies top-level values. The values of any references will be shared between the variables. To do a deep copy of an array reference and not share the values, you must dereference the array. In this case, we will dereference the array and use [] to create a new array reference.

use Data::Dumper;
my $aref1   = [ 1, 3, 7 ];
my $aref2   = [ @$aref1 ];
$aref2->[0] = 9;
print Dumper($aref1, $aref2);
That prints:
$VAR1 = [
          1,
          3,
          7
        ];
$VAR2 = [
          9,
          3,
          7
        ];

And as you can see, the two variables no longer share the same array reference.

This can particularly confuse programmers who are not aware of this. Here’s some broken code attempting to copy a data structure and clear out the sales in the new structures.

use Data::Dumper;
my %old_sales = (
    monday    => { jim => 2, mary => 1 },
    tuesday   => { jim => 3, mary => 5 },
    wednesday => { jim => 7, mary => 3 },
    thursday  => { jim => 4, mary => 5 },
    friday    => { jim => 1, mary => 2 },
);
my %new_sales = %old_sales;
while ( my ( $day, $sales ) = each %new_sales ) {
    $sales->{jim}  = 0;
    $sales->{mary} = 0;
}
print Dumper(\%old_sales, \%new_sales);

And that prints (reformatted for clarity):

$VAR1 = {
  'monday'    => { 'jim' => 0, 'mary' => 0 }
  'tuesday'   => { 'jim' => 0, 'mary' => 0 },
  'wednesday' => { 'jim' => 0, 'mary' => 0 },
  'thursday'  => { 'jim' => 0, 'mary' => 0 },
  'friday'    => { 'jim' => 0, 'mary' => 0 },
};
$VAR2 = {
  'monday'    => $VAR1->{'monday'},
  'tuesday'   => $VAR1->{'tuesday'}
  'wednesday' => $VAR1->{'wednesday'},
  'thursday'  => $VAR1->{'thursday'},
  'friday'    => $VAR1->{'friday'},
};

As you can see, we have overwritten the values in the the %old_sales hash. It would be tedious to dereference each hashref and take a reference to each hash, but it’s also error prone. A much simpler way to handle this is to use the Storable 'dclone' (deep clone) function. It does a deep copy of a reference. Example 6.2, “Using dclone to deep copy data structures” shows how it’s done.

use strict;
use warnings;
use diagnostics;
use Data::Dumper;
use Storable 'dclone';
my %old_sales = (
    monday    => { jim => 2, mary => 1 },
    tuesday   => { jim => 3, mary => 5 },
    wednesday => { jim => 7, mary => 3 },
    thursday  => { jim => 4, mary => 5 },
    friday    => { jim => 1, mary => 2 },
);
my %new_sales = %{ dclone(\%old_sales) };
while ( my ( $day, $sales ) = each %new_sales ) {
    $sales->{jim}  = 0;
    $sales->{mary} = 0;
}
print Dumper(\%old_sales, \%new_sales);

And running dclone.pl shows that we have the desired result (again, reformatted for clarity);

$VAR1 = {
  'monday'    => { 'jim' => 2, 'mary' => 1 }
  'tuesday'   => { 'jim' => 3, 'mary' => 5 },
  'wednesday' => { 'jim' => 7, 'mary' => 3 },
  'thursday'  => { 'jim' => 4, 'mary' => 5 },
  'friday'    => { 'jim' => 1, 'mary' => 2 },
};
$VAR2 = {
  'monday'    => { 'jim' => 0, 'mary' => 0 }
  'tuesday'   => { 'jim' => 0, 'mary' => 0 },
  'wednesday' => { 'jim' => 0, 'mary' => 0 },
  'thursday'  => { 'jim' => 0, 'mary' => 0 },
  'friday'    => { 'jim' => 0, 'mary' => 0 },
};

Remember, when copying references, if it’s a flat data structure like an array or hash, you can just dereference and assign the values (optionally creating a new reference):

my $acopy = [ @$aref ];
my %hcopy = %$href;

But if there are references in there, you will have a shallow copy and possibly unwanted side-effects.

When working with arrays and hashes, you sometimes want to fetch several items from the array or hash at once. You might recall that the syntax is to prefix the variable name with an @ (array) symbol and provide two or more indexes/keys.

# array slice
my @array = qw(foo bar baz quux);
my ( $var1, $var2 ) = @array[ 1, 2 ];
# hash slice
my %hash = (
    this    => 'is',
    another => 'boring',
    example => 'innit?'
);
my ( $first, $second ) = @hash{ 'another', 'example' };
print "$var1, $var2\n";
print "$first, $second\n";

And that prints:

bar, baz
boring, innit?

When you have references, you must, as expected, dereference the variables first. The following code prints the same output as the previous code. Note how we dereference the variables to get the slices.

# array slice
my $arrayref = [ qw(foo bar baz quux) ];
my ( $var1, $var2 ) = @$arrayref[ 1, 2 ];
# hash slice
my $hashref = {
    this    => 'is',
    another => 'boring',
    example => 'innit'
};
my ( $first, $second ) = @$hashref{ 'another', 'example' };
print "$var1, $var2\n";
print "$first, $second\n";

However, if you’re trying to take a slice of a complex data structure, you must use curly braces to make it clear what you are taking a slice of.

my ( $jim, $mary, $alice )
    = @{ $sales->[12]{tuesday} }{qw/ jim mary alice /};

Yes, the syntax is painful and ugly. Taking slices from references is something that often confuses newer programmers. You may wish to avoid this feature.