Node:The Semantics of Arrays,
The Semantics of Arrays
The arrays in Perl are semantically closest to lists in Lisp or Scheme
(sans cons cells), however the syntax that is used to access arrays is
closer to arrays in C. In fact, one can often treat Perl's arrays as
if they were simply C arrays, but they are actually much more powerful
Perl arrays grow and shrink dynamically as needed. The more data you
put into a Perl list, the bigger it gets. As you remove elements from
the list, the list will shrink to the right size. Note that this is
inherently different from arrays in the C language, where the programmer
must keep track and control the size of the array.
However, Perl arrays are accessible just like C arrays. So, you can
subscript to anywhere within a given list at will. There is no need to
process through the first four elements of the list to get the fifth
element (as in Scheme). In this manner, you get the advantages of both
a dynamic list, and a static-size array.
The only penalty that you pay for this flexibility is that when an array
is growing very large very quickly, it can be a bit inefficient.
However, when this must occur, Perl allows you to pre-build an array of
certain size. We will show how to do this a bit later.
A Perl array is always a list of scalars. Of course, since Perl makes
no direct distinction between numeric and string values, you can easily
mix different types of scalars within the same array. However,
everything in the array must be a scalar1.
Note the difference in terminology that is used here. Arrays refer to
variables that store a list of scalar values. Lists can be
written as literals (see List Literals) and used in a variety of
ways. One of the ways that list literals can be used is to assign to
array variables (see Array Variables). We will discuss both list
literals and array variables in this chapter.
It is possible to make
an array of arrays using a concept called ``references'', but that topic
is beyond the scope of this book.