Accessing Elements of an Array
Special Array Indices
Interpolating Arrays into Strings
The foreach Control Structure
Perl's Favorite Default: $_
Scalar and List Context
<STDIN> in List Context
If a scalar was the "singular" in Perl, as we described them at the beginning of Chapter 2, "Scalar Data", the "plural" in Perl is represented by lists and arrays.
A list is an ordered collection of scalars. An array is a variable that contains a list. In Perl, the two terms are often used as if they're interchangeable. But, to be accurate, the list is the data, and the array is the variable. You can have a list value that isn't in an array, but every array variable holds a list (although that list may be empty). Figure 3-1 represents a list, whether it's stored in an array or not.
Each element of an array or list is a separate scalar variable with an independent scalar value. These values are ordered -- that is, they have a particular sequence from the first to the last element. The elements of an array or list are indexed by small integers starting at zero and counting by ones, so the first element of any array or list is always element zero.
Array and list indices always start at zero in Perl, unlike in some other languages. In early Perl, it was possible to change the starting number of array and list indexing (not for just one array or list, but for all of them at once!). Larry later realized that this was a misfeature, and its (ab)use is now strongly discouraged. But, if you're terminally curious, look up the $[variable in the perlvarmanpage.
Since each element is an independent scalar value, a list or array may hold numbers, strings, undef values, or any mixture of different scalar values. Nevertheless, it's most common to have all elements of the same type, such as a list of book titles (all strings) or a list of cosines (all numbers).
Arrays and lists can have any number of elements. The smallest one has no elements, while the largest can fill all of available memory. Once again, this is in keeping with Perl's philosophy of "no unnecessary limits."
$fred = "yabba"; $fred = "dabba"; $fred = "doo";
The array name itself (in this case, "fred") is from a completely separate namespace than scalars use; you could have a scalar variable named $fred in the same program, and Perl will treat them as different things, and wouldn't be confused. (Your maintenance programmer might be confused, though, so don't capriciously make all of your variable names the same!)
You can use an array element like $fred in every place where you could use any other scalar variable like $fred. For example, you can get the value from an array element or change that value by the same sorts of expressions we used in the previous chapter:
Well, almost. The most notable exception is that the control variable of a foreach loop, which we'll see later in this chapter, must be a simple scalar. And there are others, like the "indirect object slot" and "indirect filehandle slot" for print and printf.
print $fred; $fred = "diddley"; $fred .= "whatsis";
Of course, the subscript may be any expression that gives a numeric value. If it's not an integer already, it'll automatically be truncated to the next lower integer:
$number = 2.71828; print $fred[$number - 1]; # Same as printing $fred
If the subscript indicates an element that would be beyond the end of the array, the corresponding value will be undef. This is just as with ordinary scalars; if you've never stored a value into the variable, it's undef.
$blank = $fred[ 142_857 ]; # unused array element gives undef $blanc = $mel; # unused scalar $mel also gives undef
Copyright © 2002 O'Reilly & Associates. All rights reserved.