# Recipe 11.1 Taking References to Arrays

#### 11.1.1 Problem

You need to manipulate an array by reference.

#### 11.1.2 Solution

To get a reference to an array:

```\$aref               = \@array;
\$anon_array         = [1, 3, 5, 7, 9];
\$anon_copy          = [ @array ];
@\$implicit_creation = (2, 4, 6, 8, 10);```

To deference an array reference, precede it with an at sign (@):

`push(@\$anon_array, 11);`

Or use a pointer arrow plus a bracketed subscript for a particular element:

`\$two = \$implicit_creation->[0];`

To get the last index number by reference, or the number of items in that referenced array:

```\$last_idx  = \$#\$aref;
\$num_items = @\$aref;```

Or defensively embracing and forcing context:

```\$last_idx  = \$#{ \$aref };
\$num_items = scalar @{ \$aref };```

#### 11.1.3 Discussion

Here are array references in action:

```# check whether \$someref contains a simple array reference
if (ref(\$someref) ne "ARRAY") {
die "Expected an array reference, not \$someref\n";
}

print "@{\$array_ref}\n";        # print original data

@order = sort @{ \$array_ref };  # sort it

push @{ \$array_ref }, \$item;    # append new element to orig array```

If you can't decide whether to use a reference to a named array or to create a new one, here's a simplistic guideline that will prove right more often than not. Only take a reference to an existing array to return the reference out of scope, thereby creating an anonymous array, or to pass the array by reference to a function. For virtually all other cases, use [@array] to create a new array reference with a copy of the old values.

Automatic reference counting and the backslash operator make a powerful combination:

```sub array_ref {
my @array;
return \@array;
}

\$aref1 = array_ref( );
\$aref2 = array_ref( );```

Each time array_ref is called, the function allocates a new piece of memory for @array. If we hadn't returned a reference to @array, its memory would have been freed when its block, the subroutine, ended. But here a reference to @array is still accessible, so Perl doesn't free that storage, and we wind up with a reference to a piece of memory no longer accessible through the symbol table. Such a piece of memory is called anonymous because it has no name associated with it.

To access a particular element of the array referenced by \$aref, you could write \$\$aref[4], but \$aref->[4] is the same thing, and clearer.

```print \$array_ref->[\$N];         # access item in position N (best)
print \$\$array_ref[\$N];          # same, but confusing
print \${\$array_ref}[\$N];        # same, but still confusing, and ugly to boot```

If you have an array reference, you can only access a slice of the referenced array in this way:

```@\$pie[3..5];                    # array slice, but a little confusing to read
@{\$pie}[3..5];                  # array slice, easier (?) to read```

Array slices, even when accessed through array references, are assignable. In the next line, the array dereference happens first, then the slice:

`@{\$pie}[3..5] = ("blackberry", "blueberry", "pumpkin");`

An array slice is just syntactic sugar for a list of individual array elements. Because you can't take a reference to a list, you can't take a reference to an array slice:

`\$sliceref = \@{\$pie}[3..5];     # WRONG!`

To iterate through the entire array, loop with foreach or for:

```foreach \$item ( @{\$array_ref} ) {
# \$item has data
}

for (\$idx = 0; \$idx <= \$#{ \$array_ref }; \$idx++) {
# \$array_ref->[\$idx] has data
}```

Chapters 8 and 9 of Programming Perl; perlref(1), perlreftut(1), and perllol(1); Recipe 2.13; Recipe 4.6

 Chapter 1. Strings
 Chapter 2. Numbers
 Chapter 3. Dates and Times
 Chapter 4. Arrays
 Chapter 5. Hashes
 Chapter 6. Pattern Matching
 Chapter 7. File Access
 Chapter 8. File Contents
 Chapter 9. Directories
 Chapter 10. Subroutines
 Chapter 12. Packages, Libraries, and Modules
 Chapter 13. Classes, Objects, and Ties
 Chapter 14. Database Access
 Chapter 15. Interactivity
 Chapter 16. Process Management and Communication
 Chapter 17. Sockets
 Chapter 18. Internet Services
 Chapter 19. CGI Programming
 Chapter 20. Web Automation
 Chapter 21. mod_perl
 Chapter 22. XML