be defensive about setting {host,group,pass}cat (from Andy Dougherty)
[p5sagit/p5-mst-13.2.git] / pod / perldata.pod
CommitLineData
a0d0e21e 1=head1 NAME
2
cb1a09d0 3perldata - Perl data types
a0d0e21e 4
5=head1 DESCRIPTION
6
7=head2 Variable names
8
d55a8828 9Perl has three built-in data types: scalars, arrays of scalars, and
10associative arrays of scalars, known as "hashes". Normal arrays
19799a22 11are ordered lists of scalars indexed by number, starting with 0 and with
d55a8828 12negative subscripts counting from the end. Hashes are unordered
19799a22 13collections of scalar values indexed by their associated string key.
a0d0e21e 14
d55a8828 15Values are usually referred to by name, or through a named reference.
b88cefa9 16The first character of the name tells you to what sort of data
17structure it refers. The rest of the name tells you the particular
d55a8828 18value to which it refers. Usually this name is a single I<identifier>,
19that is, a string beginning with a letter or underscore, and
20containing letters, underscores, and digits. In some cases, it may
21be a chain of identifiers, separated by C<::> (or by the slightly
22archaic C<'>); all but the last are interpreted as names of packages,
23to locate the namespace in which to look up the final identifier
24(see L<perlmod/Packages> for details). It's possible to substitute
25for a simple identifier, an expression that produces a reference
26to the value at runtime. This is described in more detail below
27and in L<perlref>.
28
29Perl also has its own built-in variables whose names don't follow
30these rules. They have strange names so they don't accidentally
31collide with one of your normal variables. Strings that match
32parenthesized parts of a regular expression are saved under names
33containing only digits after the C<$> (see L<perlop> and L<perlre>).
34In addition, several special variables that provide windows into
35the inner working of Perl have names containing punctuation characters
36and control characters. These are documented in L<perlvar>.
37
38Scalar values are always named with '$', even when referring to a
39scalar that is part of an array or a hash. The '$' symbol works
40semantically like the English word "the" in that it indicates a
41single value is expected.
a0d0e21e 42
43 $days # the simple scalar value "days"
44 $days[28] # the 29th element of array @days
45 $days{'Feb'} # the 'Feb' value from hash %days
46 $#days # the last index of array @days
47
d55a8828 48Entire arrays (and slices of arrays and hashes) are denoted by '@',
49which works much like the word "these" or "those" does in English,
50in that it indicates multiple values are expected.
a0d0e21e 51
52 @days # ($days[0], $days[1],... $days[n])
d55a8828 53 @days[3,4,5] # same as ($days[3],$days[4],$days[5])
a0d0e21e 54 @days{'a','c'} # same as ($days{'a'},$days{'c'})
55
d55a8828 56Entire hashes are denoted by '%':
a0d0e21e 57
58 %days # (key1, val1, key2, val2 ...)
59
d55a8828 60In addition, subroutines are named with an initial '&', though this
61is optional when unambiguous, just as the word "do" is often redundant
62in English. Symbol table entries can be named with an initial '*',
63but you don't really care about that yet (if ever :-).
64
65Every variable type has its own namespace, as do several
66non-variable identifiers. This means that you can, without fear
67of conflict, use the same name for a scalar variable, an array, or
68a hash--or, for that matter, for a filehandle, a directory handle, a
69subroutine name, a format name, or a label. This means that $foo
70and @foo are two different variables. It also means that C<$foo[1]>
71is a part of @foo, not a part of $foo. This may seem a bit weird,
72but that's okay, because it is weird.
73
74Because variable references always start with '$', '@', or '%', the
75"reserved" words aren't in fact reserved with respect to variable
76names. They I<are> reserved with respect to labels and filehandles,
77however, which don't have an initial special character. You can't
78have a filehandle named "log", for instance. Hint: you could say
79C<open(LOG,'logfile')> rather than C<open(log,'logfile')>. Using
80uppercase filehandles also improves readability and protects you
81from conflict with future reserved words. Case I<is> significant--"FOO",
82"Foo", and "foo" are all different names. Names that start with a
83letter or underscore may also contain digits and underscores.
a0d0e21e 84
85It is possible to replace such an alphanumeric name with an expression
d55a8828 86that returns a reference to the appropriate type. For a description
a0d0e21e 87of this, see L<perlref>.
88
5f05dabc 89Names that start with a digit may contain only more digits. Names
5a964f20 90that do not start with a letter, underscore, or digit are limited to
5f05dabc 91one character, e.g., C<$%> or C<$$>. (Most of these one character names
cb1a09d0 92have a predefined significance to Perl. For instance, C<$$> is the
a0d0e21e 93current process id.)
94
95=head2 Context
96
97The interpretation of operations and values in Perl sometimes depends
98on the requirements of the context around the operation or value.
d55a8828 99There are two major contexts: list and scalar. Certain operations
a0d0e21e 100return list values in contexts wanting a list, and scalar values
d55a8828 101otherwise. If this is true of an operation it will be mentioned in
102the documentation for that operation. In other words, Perl overloads
a0d0e21e 103certain operations based on whether the expected return value is
d55a8828 104singular or plural. Some words in English work this way, like "fish"
105and "sheep".
a0d0e21e 106
107In a reciprocal fashion, an operation provides either a scalar or a
108list context to each of its arguments. For example, if you say
109
110 int( <STDIN> )
111
d55a8828 112the integer operation provides scalar context for the E<lt><gt>
a0d0e21e 113operator, which responds by reading one line from STDIN and passing it
114back to the integer operation, which will then find the integer value
115of that line and return that. If, on the other hand, you say
116
117 sort( <STDIN> )
118
d55a8828 119then the sort operation provides list context for E<lt><gt>, which
a0d0e21e 120will proceed to read every line available up to the end of file, and
121pass that list of lines back to the sort routine, which will then
122sort those lines and return them as a list to whatever the context
123of the sort was.
124
d55a8828 125Assignment is a little bit special in that it uses its left argument
126to determine the context for the right argument. Assignment to a
127scalar evaluates the right-hand side in scalar context, while
128assignment to an array or hash evaluates the righthand side in list
129context. Assignment to a list (or slice, which is just a list
130anyway) also evaluates the righthand side in list context.
131
132When you use Perl's B<-w> command-line option, you may see warnings
133about useless uses of constants or functions in "void context".
134Void context just means the value has been discarded, such as a
135statement containing only C<"fred";> or C<getpwuid(0);>. It still
136counts as scalar context for functions that care whether or not
137they're being called in list context.
138
139User-defined subroutines may choose to care whether they are being
140called in a void, scalar, or list context. Most subroutines do not
141need to bother, though. That's because both scalars and lists are
142automatically interpolated into lists. See L<perlfunc/wantarray>
143for how you would dynamically discern your function's calling
144context.
a0d0e21e 145
146=head2 Scalar values
147
d55a8828 148All data in Perl is a scalar, an array of scalars, or a hash of
149scalars. A scalar may contain one single value in any of three
150different flavors: a number, a string, or a reference. In general,
151conversion from one form to another is transparent. Although a
152scalar may not directly hold multiple values, it may contain a
153reference to an array or hash which in turn contains multiple values.
154
155Scalars aren't necessarily one thing or another. There's no place
156to declare a scalar variable to be of type "string", type "number",
157type "reference", or anything else. Because of the automatic
158conversion of scalars, operations that return scalars don't need
159to care (and in fact, cannot care) whether their caller is looking
160for a string, a number, or a reference. Perl is a contextually
161polymorphic language whose scalars can be strings, numbers, or
162references (which includes objects). Although strings and numbers
163are considered pretty much the same thing for nearly all purposes,
164references are strongly-typed, uncastable pointers with builtin
165reference-counting and destructor invocation.
a0d0e21e 166
167A scalar value is interpreted as TRUE in the Boolean sense if it is not
19799a22 168the null string or the number 0 (or its string equivalent, "0"). The
d55a8828 169Boolean context is just a special kind of scalar context where no
170conversion to a string or a number is ever performed.
171
172There are actually two varieties of null strings (sometimes referred
173to as "empty" strings), a defined one and an undefined one. The
174defined version is just a string of length zero, such as C<"">.
175The undefined version is the value that indicates that there is
176no real value for something, such as when there was an error, or
177at end of file, or when you refer to an uninitialized variable or
178element of an array or hash. Although in early versions of Perl,
179an undefined scalar could become defined when first used in a
180place expecting a defined value, this no longer happens except for
181rare cases of autovivification as explained in L<perlref>. You can
182use the defined() operator to determine whether a scalar value is
183defined (this has no meaning on arrays or hashes), and the undef()
184operator to produce an undefined value.
185
186To find out whether a given string is a valid non-zero number, it's
187sometimes enough to test it against both numeric 0 and also lexical
188"0" (although this will cause B<-w> noises). That's because strings
189that aren't numbers count as 0, just as they do in B<awk>:
4633a7c4 190
191 if ($str == 0 && $str ne "0") {
192 warn "That doesn't look like a number";
54310121 193 }
4633a7c4 194
d55a8828 195That method may be best because otherwise you won't treat IEEE
196notations like C<NaN> or C<Infinity> properly. At other times, you
197might prefer to determine whether string data can be used numerically
198by calling the POSIX::strtod() function or by inspecting your string
199with a regular expression (as documented in L<perlre>).
cb1a09d0 200
201 warn "has nondigits" if /\D/;
5a964f20 202 warn "not a natural number" unless /^\d+$/; # rejects -3
203 warn "not an integer" unless /^-?\d+$/; # rejects +3
204 warn "not an integer" unless /^[+-]?\d+$/;
205 warn "not a decimal number" unless /^-?\d+\.?\d*$/; # rejects .2
206 warn "not a decimal number" unless /^-?(?:\d+(?:\.\d*)?|\.\d+)$/;
54310121 207 warn "not a C float"
cb1a09d0 208 unless /^([+-]?)(?=\d|\.\d)\d*(\.\d*)?([Ee]([+-]?\d+))?$/;
209
d55a8828 210The length of an array is a scalar value. You may find the length
211of array @days by evaluating C<$#days>, as in B<csh>. Technically
212speaking, this isn't the length of the array; it's the subscript
213of the last element, since there is ordinarily a 0th element.
214Assigning to C<$#days> actually changes the length of the array.
215Shortening an array this way destroys intervening values. Lengthening
216an array that was previously shortened does not recover values
217that were in those elements. (It used to do so in Perl 4, but we
218had to break this to make sure destructors were called when expected.)
219
220You can also gain some miniscule measure of efficiency by pre-extending
221an array that is going to get big. You can also extend an array
222by assigning to an element that is off the end of the array. You
19799a22 223can truncate an array down to nothing by assigning the null list
d55a8828 224() to it. The following are equivalent:
a0d0e21e 225
226 @whatever = ();
3e3baf6d 227 $#whatever = -1;
a0d0e21e 228
d55a8828 229If you evaluate an array in scalar context, it returns the length
230of the array. (Note that this is not true of lists, which return
231the last value, like the C comma operator, nor of built-in functions,
232which return whatever they feel like returning.) The following is
233always true:
a0d0e21e 234
235 scalar(@whatever) == $#whatever - $[ + 1;
236
184e9718 237Version 5 of Perl changed the semantics of C<$[>: files that don't set
238the value of C<$[> no longer need to worry about whether another
239file changed its value. (In other words, use of C<$[> is deprecated.)
5f05dabc 240So in general you can assume that
a0d0e21e 241
242 scalar(@whatever) == $#whatever + 1;
243
d55a8828 244Some programmers choose to use an explicit conversion so as to
245leave nothing to doubt:
4633a7c4 246
247 $element_count = scalar(@whatever);
248
d55a8828 249If you evaluate a hash in scalar context, it returns false if the
250hash is empty. If there are any key/value pairs, it returns true;
251more precisely, the value returned is a string consisting of the
252number of used buckets and the number of allocated buckets, separated
253by a slash. This is pretty much useful only to find out whether
254Perl's internal hashing algorithm is performing poorly on your data
255set. For example, you stick 10,000 things in a hash, but evaluating
256%HASH in scalar context reveals C<"1/16">, which means only one out
257of sixteen buckets has been touched, and presumably contains all
25810,000 of your items. This isn't supposed to happen.
a0d0e21e 259
5a964f20 260You can preallocate space for a hash by assigning to the keys() function.
261This rounds up the allocated bucked to the next power of two:
262
263 keys(%users) = 1000; # allocate 1024 buckets
264
a0d0e21e 265=head2 Scalar value constructors
266
d55a8828 267Numeric literals are specified in any of the following floating point or
a0d0e21e 268integer formats:
269
a0d0e21e 270 12345
271 12345.67
d55a8828 272 .23E-10 # a very small number
273 4_294_967_296 # underline for legibility
274 0xff # hex
275 0377 # octal
276 0b011011 # binary
a0d0e21e 277
55497cff 278String literals are usually delimited by either single or double
d55a8828 279quotes. They work much like quotes in the standard Unix shells:
280double-quoted string literals are subject to backslash and variable
19799a22 281substitution; single-quoted strings are not (except for C<\'> and
282C<\\>). The usual C-style backslash rules apply for making
d55a8828 283characters such as newline, tab, etc., as well as some more exotic
284forms. See L<perlop/"Quote and Quotelike Operators"> for a list.
285
286Hexadecimal, octal, or binary, representations in string literals
287(e.g. '0xff') are not automatically converted to their integer
288representation. The hex() and oct() functions make these conversions
289for you. See L<perlfunc/hex> and L<perlfunc/oct> for more details.
68dc0745 290
5f05dabc 291You can also embed newlines directly in your strings, i.e., they can end
a0d0e21e 292on a different line than they begin. This is nice, but if you forget
293your trailing quote, the error will not be reported until Perl finds
294another line containing the quote character, which may be much further
295on in the script. Variable substitution inside strings is limited to
d55a8828 296scalar variables, arrays, and array or hash slices. (In other words,
b88cefa9 297names beginning with $ or @, followed by an optional bracketed
a0d0e21e 298expression as a subscript.) The following code segment prints out "The
184e9718 299price is $Z<>100."
a0d0e21e 300
301 $Price = '$100'; # not interpreted
302 print "The price is $Price.\n"; # interpreted
303
d55a8828 304As in some shells, you can enclose the variable name in braces to
305disambiguate it from following alphanumerics. You must also do
306this when interpolating a variable into a string to separate the
307variable name from a following double-colon or an apostrophe, since
308these would be otherwise treated as a package separator:
309
310 $who = "Larry";
311 print PASSWD "${who}::0:0:Superuser:/:/bin/perl\n";
312 print "We use ${who}speak when ${who}'s here.\n";
313
314Without the braces, Perl would have looked for a $whospeak, a
315C<$who::0>, and a C<$who's> variable. The last two would be the
316$0 and the $s variables in the (presumably) non-existent package
317C<who>.
318
319In fact, an identifier within such curlies is forced to be a string,
320as is any simple identifier within a hash subscript. Neither need
321quoting. Our earlier example, C<$days{'Feb'}> can be written as
322C<$days{Feb}> and the quotes will be assumed automatically. But
323anything more complicated in the subscript will be interpreted as
324an expression.
325
326The special literals __FILE__, __LINE__, and __PACKAGE__
68dc0745 327represent the current filename, line number, and package name at that
328point in your program. They may be used only as separate tokens; they
329will not be interpolated into strings. If there is no current package
3e92a254 330(due to an empty C<package;> directive), __PACKAGE__ is the undefined
331value.
332
333The two control characters ^D and ^Z, and the tokens __END__ and __DATA__
334may be used to indicate the logical end of the script before the actual
335end of file. Any following text is ignored.
336
337Text after __DATA__ but may be read via the filehandle C<PACKNAME::DATA>,
338where C<PACKNAME> is the package that was current when the __DATA__
339token was encountered. The filehandle is left open pointing to the
340contents after __DATA__. It is the program's responsibility to
341C<close DATA> when it is done reading from it. For compatibility with
342older scripts written before __DATA__ was introduced, __END__ behaves
343like __DATA__ in the toplevel script (but not in files loaded with
344C<require> or C<do>) and leaves the remaining contents of the
345file accessible via C<main::DATA>.
346
347See L<SelfLoader> for more description of __DATA__, and
d55a8828 348an example of its use. Note that you cannot read from the DATA
349filehandle in a BEGIN block: the BEGIN block is executed as soon
350as it is seen (during compilation), at which point the corresponding
a00c1fe5 351__DATA__ (or __END__) token has not yet been seen.
a0d0e21e 352
748a9306 353A word that has no other interpretation in the grammar will
a0d0e21e 354be treated as if it were a quoted string. These are known as
355"barewords". As with filehandles and labels, a bareword that consists
356entirely of lowercase letters risks conflict with future reserved
357words, and if you use the B<-w> switch, Perl will warn you about any
358such words. Some people may wish to outlaw barewords entirely. If you
359say
360
361 use strict 'subs';
362
363then any bareword that would NOT be interpreted as a subroutine call
364produces a compile-time error instead. The restriction lasts to the
54310121 365end of the enclosing block. An inner block may countermand this
a0d0e21e 366by saying C<no strict 'subs'>.
367
d55a8828 368Arrays and slices are interpolated into double-quoted strings
369by joining the elements with the delimiter specified in the C<$">
370variable (C<$LIST_SEPARATOR> in English), space by default. The
371following are equivalent:
a0d0e21e 372
d55a8828 373 $temp = join($", @ARGV);
a0d0e21e 374 system "echo $temp";
375
376 system "echo @ARGV";
377
378Within search patterns (which also undergo double-quotish substitution)
d55a8828 379there is an unfortunate ambiguity: Is C</$foo[bar]/> to be interpreted as
a0d0e21e 380C</${foo}[bar]/> (where C<[bar]> is a character class for the regular
381expression) or as C</${foo[bar]}/> (where C<[bar]> is the subscript to array
382@foo)? If @foo doesn't otherwise exist, then it's obviously a
383character class. If @foo exists, Perl takes a good guess about C<[bar]>,
384and is almost always right. If it does guess wrong, or if you're just
385plain paranoid, you can force the correct interpretation with curly
d55a8828 386braces as above.
a0d0e21e 387
d55a8828 388A line-oriented form of quoting is based on the shell "here-document"
55497cff 389syntax. Following a C<E<lt>E<lt>> you specify a string to terminate
390the quoted material, and all lines following the current line down to
391the terminating string are the value of the item. The terminating
392string may be either an identifier (a word), or some quoted text. If
393quoted, the type of quotes you use determines the treatment of the
394text, just as in regular quoting. An unquoted identifier works like
395double quotes. There must be no space between the C<E<lt>E<lt>> and
396the identifier. (If you put a space it will be treated as a null
3fe9a6f1 397identifier, which is valid, and matches the first empty line.) The
55497cff 398terminating string must appear by itself (unquoted and with no
399surrounding whitespace) on the terminating line.
a0d0e21e 400
54310121 401 print <<EOF;
a0d0e21e 402 The price is $Price.
403 EOF
404
405 print <<"EOF"; # same as above
406 The price is $Price.
407 EOF
408
a0d0e21e 409 print <<`EOC`; # execute commands
410 echo hi there
411 echo lo there
412 EOC
413
414 print <<"foo", <<"bar"; # you can stack them
415 I said foo.
416 foo
417 I said bar.
418 bar
419
d28ebecd 420 myfunc(<<"THIS", 23, <<'THAT');
a0d0e21e 421 Here's a line
422 or two.
423 THIS
54310121 424 and here's another.
a0d0e21e 425 THAT
426
54310121 427Just don't forget that you have to put a semicolon on the end
428to finish the statement, as Perl doesn't know you're not going to
a0d0e21e 429try to do this:
430
431 print <<ABC
432 179231
433 ABC
434 + 20;
435
d55a8828 436If you want your here-docs to be indented with the
437rest of the code, you'll need to remove leading whitespace
438from each line manually:
439
440 ($quote = <<'FINIS') =~ s/^\s+//gm;
441 The Road goes ever on and on,
442 down from the door where it began.
443 FINIS
a0d0e21e 444
445=head2 List value constructors
446
447List values are denoted by separating individual values by commas
448(and enclosing the list in parentheses where precedence requires it):
449
450 (LIST)
451
d55a8828 452In a context not requiring a list value, the value of what appears
453to be a list literal is simply the value of the final element, as
454with the C comma operator. For example,
a0d0e21e 455
456 @foo = ('cc', '-E', $bar);
457
d55a8828 458assigns the entire list value to array @foo, but
a0d0e21e 459
460 $foo = ('cc', '-E', $bar);
461
d55a8828 462assigns the value of variable $bar to the scalar variable $foo.
463Note that the value of an actual array in scalar context is the
464length of the array; the following assigns the value 3 to $foo:
a0d0e21e 465
466 @foo = ('cc', '-E', $bar);
467 $foo = @foo; # $foo gets 3
468
54310121 469You may have an optional comma before the closing parenthesis of a
a0d0e21e 470list literal, so that you can say:
471
472 @foo = (
473 1,
474 2,
475 3,
476 );
477
d55a8828 478To use a here-document to assign an array, one line per element,
479you might use an approach like this:
480
481 @sauces = <<End_Lines =~ m/(\S.*\S)/g;
482 normal tomato
483 spicy tomato
484 green chile
485 pesto
486 white wine
487 End_Lines
488
a0d0e21e 489LISTs do automatic interpolation of sublists. That is, when a LIST is
d55a8828 490evaluated, each element of the list is evaluated in list context, and
a0d0e21e 491the resulting list value is interpolated into LIST just as if each
5a964f20 492individual element were a member of LIST. Thus arrays and hashes lose their
a0d0e21e 493identity in a LIST--the list
494
5a964f20 495 (@foo,@bar,&SomeSub,%glarch)
a0d0e21e 496
497contains all the elements of @foo followed by all the elements of @bar,
5a964f20 498followed by all the elements returned by the subroutine named SomeSub
d55a8828 499called in list context, followed by the key/value pairs of %glarch.
a0d0e21e 500To make a list reference that does I<NOT> interpolate, see L<perlref>.
501
19799a22 502The null list is represented by (). Interpolating it in a list
a0d0e21e 503has no effect. Thus ((),(),()) is equivalent to (). Similarly,
504interpolating an array with no elements is the same as if no
505array had been interpolated at that point.
506
507A list value may also be subscripted like a normal array. You must
54310121 508put the list in parentheses to avoid ambiguity. For example:
a0d0e21e 509
510 # Stat returns list value.
511 $time = (stat($file))[8];
512
4633a7c4 513 # SYNTAX ERROR HERE.
5f05dabc 514 $time = stat($file)[8]; # OOPS, FORGOT PARENTHESES
4633a7c4 515
a0d0e21e 516 # Find a hex digit.
517 $hexdigit = ('a','b','c','d','e','f')[$digit-10];
518
519 # A "reverse comma operator".
520 return (pop(@foo),pop(@foo))[0];
521
d55a8828 522Lists may be assigned to only when each element of the list
523is itself legal to assign to:
a0d0e21e 524
525 ($a, $b, $c) = (1, 2, 3);
526
527 ($map{'red'}, $map{'blue'}, $map{'green'}) = (0x00f, 0x0f0, 0xf00);
528
d55a8828 529An exception to this is that you may assign to C<undef> in a list.
530This is useful for throwing away some of the return values of a
531function:
532
533 ($dev, $ino, undef, undef, $uid, $gid) = stat($file);
534
535List assignment in scalar context returns the number of elements
4633a7c4 536produced by the expression on the right side of the assignment:
537
538 $x = (($foo,$bar) = (3,2,1)); # set $x to 3, not 2
539 $x = (($foo,$bar) = f()); # set $x to f()'s return count
540
d55a8828 541This is handy when you want to do a list assignment in a Boolean
19799a22 542context, because most list functions return a null list when finished,
4633a7c4 543which when assigned produces a 0, which is interpreted as FALSE.
544
a0d0e21e 545The final element may be an array or a hash:
546
547 ($a, $b, @rest) = split;
5a964f20 548 my($a, $b, %rest) = @_;
a0d0e21e 549
4633a7c4 550You can actually put an array or hash anywhere in the list, but the first one
d55a8828 551in the list will soak up all the values, and anything after it will become
552undefined. This may be useful in a my() or local().
a0d0e21e 553
d55a8828 554A hash can be initialized using a literal list holding pairs of
555items to be interpreted as a key and a value:
a0d0e21e 556
557 # same as map assignment above
558 %map = ('red',0x00f,'blue',0x0f0,'green',0xf00);
559
d55a8828 560While literal lists and named arrays are often interchangeable, that's
4633a7c4 561not the case for hashes. Just because you can subscript a list value like
562a normal array does not mean that you can subscript a list value as a
563hash. Likewise, hashes included as parts of other lists (including
564parameters lists and return lists from functions) always flatten out into
565key/value pairs. That's why it's good to use references sometimes.
a0d0e21e 566
4633a7c4 567It is often more readable to use the C<=E<gt>> operator between key/value
568pairs. The C<=E<gt>> operator is mostly just a more visually distinctive
b88cefa9 569synonym for a comma, but it also arranges for its left-hand operand to be
5a964f20 570interpreted as a string--if it's a bareword that would be a legal identifier.
b88cefa9 571This makes it nice for initializing hashes:
a0d0e21e 572
4633a7c4 573 %map = (
574 red => 0x00f,
575 blue => 0x0f0,
576 green => 0xf00,
577 );
578
579or for initializing hash references to be used as records:
580
581 $rec = {
582 witch => 'Mable the Merciless',
583 cat => 'Fluffy the Ferocious',
584 date => '10/31/1776',
585 };
586
587or for using call-by-named-parameter to complicated functions:
588
54310121 589 $field = $query->radio_group(
4633a7c4 590 name => 'group_name',
591 values => ['eenie','meenie','minie'],
592 default => 'meenie',
593 linebreak => 'true',
594 labels => \%labels
595 );
cb1a09d0 596
597Note that just because a hash is initialized in that order doesn't
598mean that it comes out in that order. See L<perlfunc/sort> for examples
599of how to arrange for an output ordering.
600
d55a8828 601=head2 Slices
602
603A common way access an array or a hash is one scalar element at a time.
604You can also subscript a list to get a single element from it.
605
606 $whoami = $ENV{"USER"}; # one element from the hash
607 $parent = $ISA[0]; # one element from the array
608 $dir = (getpwnam("daemon"))[7]; # likewise, but with list
609
610A slice accesses several elements of a list, an array, or a hash
611simultaneously using a list of subscripts. It's a more convenient
612that writing out the individual elements as a list of separate
613scalar values.
614
615 ($him, $her) = @folks[0,-1]; # array slice
616 @them = @folks[0 .. 3]; # array slice
617 ($who, $home) = @ENV{"USER", "HOME"}; # hash slice
618 ($uid, $dir) = (getpwnam("daemon"))[2,7]; # list slice
619
620Since you can assign to a list of variables, you can also assign to
621an array or hash slice.
622
623 @days[3..5] = qw/Wed Thu Fri/;
624 @colors{'red','blue','green'}
625 = (0xff0000, 0x0000ff, 0x00ff00);
626 @folks[0, -1] = @folks[-1, 0];
627
628The previous assignments are exactly equivalent to
629
630 ($days[3], $days[4], $days[5]) = qw/Wed Thu Fri/;
631 ($colors{'red'}, $colors{'blue'}, $colors{'green'})
632 = (0xff0000, 0x0000ff, 0x00ff00);
633 ($folks[0], $folks[-1]) = ($folks[0], $folks[-1]);
634
635Since changing a slice changes the original array or hash that it's
636slicing, a C<foreach> construct will alter through some--or even
637all--of the values of the array or hash.
638
639 foreach (@array[ 4 .. 10 ]) { s/peter/paul/ }
640
641 foreach (@hash{keys %hash}) {
642 s/^\s+//; # trim leading whitespace
643 s/\s+$//; # trim trailing whitespace
644 s/(\w+)/\u\L$1/g; # "titlecase" words
645 }
646
647You couldn't just loop through C<values %hash> to do this because
648that function produces a new list which is a copy of the values,
649so changing them doesn't change the original.
650
08cd8952 651A slice of an empty list is still an empty list. Thus:
652
653 @a = ()[1,0]; # @a has no elements
654 @b = (@a)[0,1]; # @b has no elements
655 @b = (1,undef)[1,0,1]; # @b has three elements
656
19799a22 657This makes it easy to write loops that terminate when a null list
658is returned:
d55a8828 659
660 while ( ($home, $user) = (getpwent)[7,0]) {
661 printf "%-8s %s\n", $user, $home;
662 }
663
664As noted earlier in this document, the scalar sense of list assignment
665is the number of elements on the right-hand side of the assignment.
19799a22 666The null list contains no elements, so when the password file is
d55a8828 667exhausted, the result is 0, not 2.
668
669If you're confused about why you use an '@' there on a hash slice
670instead of a '%', think of it like this. The type of bracket (square
671or curly) governs whether it's an array or a hash being looked at.
672On the other hand, the leading symbol ('$' or '@') on the array or
673hash indicates whether you are getting back a singular value (a
674scalar) or a plural one (a list).
675
5f05dabc 676=head2 Typeglobs and Filehandles
cb1a09d0 677
678Perl uses an internal type called a I<typeglob> to hold an entire
679symbol table entry. The type prefix of a typeglob is a C<*>, because
54310121 680it represents all types. This used to be the preferred way to
cb1a09d0 681pass arrays and hashes by reference into a function, but now that
5a964f20 682we have real references, this is seldom needed.
683
684The main use of typeglobs in modern Perl is create symbol table aliases.
685This assignment:
686
687 *this = *that;
688
689makes $this an alias for $that, @this an alias for @that, %this an alias
690for %that, &this an alias for &that, etc. Much safer is to use a reference.
691This:
5f05dabc 692
5a964f20 693 local *Here::blue = \$There::green;
694
695temporarily makes $Here::blue an alias for $There::green, but doesn't
696make @Here::blue an alias for @There::green, or %Here::blue an alias for
697%There::green, etc. See L<perlmod/"Symbol Tables"> for more examples
698of this. Strange though this may seem, this is the basis for the whole
699module import/export system.
700
d55a8828 701Another use for typeglobs is to pass filehandles into a function or
5a964f20 702to create new filehandles. If you need to use a typeglob to save away
703a filehandle, do it this way:
5f05dabc 704
705 $fh = *STDOUT;
706
707or perhaps as a real reference, like this:
708
709 $fh = \*STDOUT;
710
5a964f20 711See L<perlsub> for examples of using these as indirect filehandles
712in functions.
713
714Typeglobs are also a way to create a local filehandle using the local()
715operator. These last until their block is exited, but may be passed back.
716For example:
5f05dabc 717
718 sub newopen {
719 my $path = shift;
d55a8828 720 local *FH; # not my!
5a964f20 721 open (FH, $path) or return undef;
e05a3a1e 722 return *FH;
5f05dabc 723 }
724 $fh = newopen('/etc/passwd');
725
d55a8828 726Now that we have the C<*foo{THING}> notation, typeglobs aren't used as much
5a964f20 727for filehandle manipulations, although they're still needed to pass brand
728new file and directory handles into or out of functions. That's because
d55a8828 729C<*HANDLE{IO}> only works if HANDLE has already been used as a handle.
730In other words, C<*FH> must be used to create new symbol table entries;
731C<*foo{THING}> cannot. When in doubt, use C<*FH>.
732
733Another way to create anonymous filehandles is with the Symbol
734module or with the IO::Handle module and its ilk. These modules
735have the advantage of not hiding different types of the same name
736during the local(). See the bottom of L<perlfunc/open()> for an
737example.
738
739=head1 SEE ALSO
740
741See L<perlvar> for a description of Perl's built-in variables and
742a discussion of legal variable names. See L<perlref>, L<perlsub>,
743and L<perlmod/"Symbol Tables"> for more discussion on typeglobs and
744the C<*foo{THING}> syntax.