Section 3.3. List Literals

3.3. List Literals

An array (the way you represent a list value within your program) is a list of comma-separated values enclosed in parentheses. These values form the elements of the list:

(1, 2, 3)      # list of three values 1, 2, and 3
    (1, 2, 3,)     # the same three values (the trailing comma is ignored)
    ("fred", 4.5)  # two values, "fred" and 4.5

    ( )            # empty list - zero elements
    (1..100)       # list of 100 integers

That last one uses the .. range operator , seen here for the first time, which creates a list of values by counting from the left scalar up to the right scalar by ones:

(1..5)            # same as (1, 2, 3, 4, 5)
    (1.7..5.7)        # same thing - both values are truncated
    (5..1)            # empty list - .. only counts "uphill"
    (0, 2..6, 10, 12) # same as (0, 2, 3, 4, 5, 6, 10, 12)
    ($m..$n)          # range determined by current values of $m and $n
    (0..$#rocks)      # the indices of the rocks array from the previous section

As you can see from those last two items, the elements of a list literal are not necessarily constantsthey can be expressions that will be newly evaluated each time the literal is used:

($m, 17)       # two values: the current value of $m, and 17
    ($m+$o, $p+$q) # two values

Of course, a list may have any scalar values, like this typical list of strings:

("fred", "barney", "betty", "wilma", "dino")

3.3.1. The qw Shortcut

It turns out that lists of simple words (like the previous example) are frequently needed in Perl programs. The qw shortcut makes it easy to generate them without typing a lot of extra quote marks:

qw( fred barney betty wilma dino ) # same as above, but less typing

qw stands for "quoted words" or "quoted by whitespace," depending upon whom you ask. Either way, Perl treats it like a single-quoted string so, you can't use \n or $fred inside a qw list as you would in a double-quoted string. The whitespace ( characters like spaces, tabs, and newlines) will be discarded, and whatever remains becomes the list of items. Since whitespace is discarded, here's another (but unusual) way to write that same list:

qw(fred
      barney     betty
    wilma dino)  # same as above, but pretty strange whitespace

Since qw is a form of quoting, you can't put comments inside a qw list.

The previous two examples have used parentheses as the delimiter, but Perl lets you choose any punctuation character as the delimiter . Here are some of the common ones:

qw! fred barney betty wilma dino !
    qw# fred barney betty wilma dino #   # like in a comment!
    qw( fred barney betty wilma dino )
    qw{ fred barney betty wilma dino }

    qw[ fred barney betty wilma dino ]
    qw< fred barney betty wilma dino >

As those last four show, sometimes the two delimiters can be different. If the opening delimiter is one of those "left" characters, the corresponding "right" character is the proper closing delimiter. Other delimiters use the same character for start and finish.

If you need to include the closing delimiter within the string as one of the characters, you probably picked the wrong delimeter. But if you can't or don't want to change the delimiter, you can include the character using the backslash:

qw! yahoo\! google excite lycos ! # include yahoo! as an element

As in single-quoted strings, two consecutive backslashes contribute one single backslash to the item.

Though the Perl motto is "There's More Than One Way To Do It," you may well wonder why anyone would need all of those different ways. Well, you'll see later there are other kinds of quoting where Perl uses this same rule, and it can come in handy in many of those. But even here, it could be useful if you were to need a list of Unix filenames:

qw{
      /usr/dict/words
      /home/rootbeer/.ispell_english
    }

That list would be inconvenient to read, write, and maintain if the slash were the only available delimiter.