Basics — taking references and using them#

There are only two ways to make a reference to something that already has a name, and only two ways to use a reference once you have it. This chapter covers both. Anonymous constructors ([...], {...}) are covered in Anonymous references.

Making a reference with backslash#

Put a backslash in front of any variable, and you get a scalar that refers to it:

my @array = (1, 2, 3);
my %hash  = (APR => 4, AUG => 8);
my $n     = 42;

my $aref  = \@array;   # reference to the array
my $href  = \%hash;    # reference to the hash
my $sref  = \$n;       # reference to the scalar

A reference is itself a scalar. You can copy it, pass it, store it in another data structure, without touching the thing it points at:

my $copy   = $aref;    # two scalars, one underlying array
my @slots;
$slots[3]  = $href;    # hash reference stored as an array element
my $pulled = $slots[3];

Both $aref and $copy point at the same array. Changing the array through one is visible through the other. To actually copy the contents, see Anonymous references.

What a reference prints as#

Stringify a reference and you get a type tag plus an address:

print "$aref\n";       # ARRAY(0x55d3c1a02b40)
print "$href\n";       # HASH(0x55d3c1a02be0)

If you ever see output like that by accident, you printed the reference where you meant to print the contents.

Using a reference — the curly-brace form#

Wherever you could have written a variable name, you can put the reference in curly braces instead. The rule is mechanical:

Operation on @array

Same operation via $aref

@array

@{$aref}

scalar @array

scalar @{$aref}

$array[3]

${$aref}[3]

$array[3] = 17

${$aref}[3] = 17

for my $x (@array) { ... }

for my $x (@{$aref}) { ... }

Hashes follow the same pattern:

Operation on %hash

Same operation via $href

%hash

%{$href}

keys %hash

keys %{$href}

$hash{red}

${$href}{red}

$hash{red} = 17

${$href}{red} = 17

And scalars:

my $x   = 10;
my $ref = \$x;
print ${$ref};         # 10
${$ref} = 99;
print $x;              # 99

The curly braces can usually be dropped when what’s inside is a plain scalar variable: @$aref means the same as @{$aref}, and $$sref means the same as ${$sref}. Start with the curly form until the short form stops looking ambiguous; $$hash{key} and ${$hash}{key} both work, but $$table{$country}[0] is easier to misread than ${$table}{$country}[0].

Using a reference — the arrow form#

The most common thing you do with a reference is fetch one element out of the array or hash it points at. The curly form works (${$aref}[3]) but is hard to read. The arrow form is the abbreviation:

$aref->[3]             # same as ${$aref}[3]
$href->{red}           # same as ${$href}{red}

The arrow is not cosmetic. It is the thing that distinguishes two different meanings:

$aref->[3]             # fourth element of the array $aref points at
$aref[3]               # fourth element of the unrelated array @aref

$aref and @aref are separate variables, as unrelated as $x and @x. Forgetting the arrow silently fetches from a different array that probably does not exist. Running under use strict turns the mistake into a compile-time error instead of a silent wrong answer at runtime.

Asking what a reference points at#

The ref built-in returns a string describing the referent’s kind:

ref $aref              # ARRAY
ref $href              # HASH
ref $sref              # SCALAR
ref \&printer          # CODE
ref $n                 # empty string — $n isn't a reference

Combine with boolean context to test “is this a reference?”:

if (ref $maybe) {
    # it's a reference of some kind
}
if (ref $maybe eq 'ARRAY') {
    # it's specifically an array reference
}

See ref for the full list of return strings (including CODE, GLOB, REF, Regexp, and the package name when the reference has been blessed into a class).

Two common beginner mistakes#

  • Treating a reference like the underlying container. push $aref, 1 does not push into the array; it’s a type error. You must dereference: push @{$aref}, 1 or (equivalently) push @$aref, 1.

  • Dropping the arrow between a variable and its subscript. $aref[3] is not the same as $aref->[3]. The first reads from @aref, the second reads through the reference.

Where to go next#

  • Arrays of arrays — the two-dimensional case, and the arrow-between-subscripts rule.

  • Anonymous references — [...] and {...} for building structures without named intermediates.