References

Introduction

So far, every array and hash you have used has been a flat, standalone variable. Real-world data is rarely that simple — think of a list of employees, each with their own set of properties, or a hash of departments, each containing a list of employees. Perl's answer to this is references: a reference is a scalar value that points at another piece of data, similar to a pointer in C or a reference in other languages.

What Is a Reference?

A reference is a scalar value that stores the location of another piece of data — an array, a hash, a scalar, or even a subroutine — rather than a copy of that data itself. Because a reference is just a scalar, you can store it in a normal $variable, pass it to subroutines cheaply (no copying a huge array), and store several of them inside another array or hash to build nested structures.

Creating a Reference

You create a reference to an existing variable by putting a backslash (\) in front of it. This works for arrays, hashes, and scalars alike.

use strict;
use warnings;

my @colors = ('red', 'green', 'blue');
my %capital = (France => 'Paris', Japan => 'Tokyo');
my $number = 42;

my $array_ref  = \@colors;
my $hash_ref   = \%capital;
my $scalar_ref = \$number;

print "Array ref: $array_ref\n";
print "Hash ref: $hash_ref\n";
print "Scalar ref: $scalar_ref\n";

The exact hexadecimal address will differ every time you run the program — what matters is that Perl labels the reference with its type (ARRAY, HASH, SCALAR), which is how you can tell what kind of data a reference points to.

Dereferencing an Array Reference

To get back to the original data from a reference, you dereference it. The classic syntax wraps the reference in curly braces and prefixes it with the sigil that matches the data type: @{$array_ref} for the whole array, or ${$array_ref}[0] for a single element. Modern Perl also allows a much cleaner arrow syntax: $array_ref->[0].

use strict;
use warnings;

my @colors = ('red', 'green', 'blue');
my $array_ref = \@colors;

print "Whole array: @{$array_ref}\n";
print "First color (arrow syntax): $array_ref->[0]\n";
print "Second color (classic syntax): ${$array_ref}[1]\n";

foreach my $color (@{$array_ref}) {
    print "Color: $color\n";
}

Dereferencing a Hash Reference

Hash references follow the same pattern: %{$hash_ref} for the whole hash, or the much more common $hash_ref->{key} arrow syntax to access a single value.

use strict;
use warnings;

my %capital = (France => 'Paris', Japan => 'Tokyo');
my $hash_ref = \%capital;

print "France's capital: $hash_ref->{France}\n";

foreach my $country (keys %{$hash_ref}) {
    print "$country -> $hash_ref->{$country}\n";
}

Anonymous References

You do not need a named array or hash before you can reference it. Square brackets [] create an anonymous array reference directly, and curly braces {} create an anonymous hash reference directly — with no separate @array or %hash variable involved at all.

use strict;
use warnings;

my $fruits_ref = ['apple', 'banana', 'cherry'];
my $person_ref = { name => 'Alice', age => 30 };

print "Second fruit: $fruits_ref->[1]\n";
print "Person's name: $person_ref->{name}\n";

Why References Matter

Without references, an array or hash can only hold scalars — you could never put "an array" directly inside another array, because a value in a Perl list is always flattened into individual scalars. A reference to an array, however, IS a single scalar, so it can happily live inside another array or hash. This is precisely how Perl builds nested structures like an array of hashes or a hash of arrays, which the next lesson covers in detail.

use strict;
use warnings;

my @team_a = ('Alice', 'Bob');
my @team_b = ('Carol', 'Dave');

my @all_teams = (\@team_a, \@team_b);

foreach my $team_ref (@all_teams) {
    print "Team: @{$team_ref}\n";
}

Common Mistakes

Best Practices

Frequently Asked Questions

Key Takeaways

Summary

References are the key that unlocks complex, real-world data modeling in Perl. Now that you understand how they work, the next lesson puts them to use building arrays of hashes, hashes of arrays, and other nested structures you will see constantly in production Perl code.