This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
[win32] another maintpatch (this one needed adjust of test nos.)
[perl5.git] / pod / perlop.pod
CommitLineData
a0d0e21e
LW
1=head1 NAME
2
3perlop - Perl operators and precedence
4
5=head1 SYNOPSIS
6
7Perl operators have the following associativity and precedence,
8listed from highest precedence to lowest. Note that all operators
9borrowed from C keep the same precedence relationship with each other,
10even where C's precedence is slightly screwy. (This makes learning
54310121 11Perl easier for C folks.) With very few exceptions, these all
c07a80fd 12operate on scalar values only, not array values.
a0d0e21e
LW
13
14 left terms and list operators (leftward)
15 left ->
16 nonassoc ++ --
17 right **
18 right ! ~ \ and unary + and -
54310121 19 left =~ !~
a0d0e21e
LW
20 left * / % x
21 left + - .
22 left << >>
23 nonassoc named unary operators
24 nonassoc < > <= >= lt gt le ge
25 nonassoc == != <=> eq ne cmp
26 left &
27 left | ^
28 left &&
29 left ||
137443ea 30 nonassoc .. ...
a0d0e21e
LW
31 right ?:
32 right = += -= *= etc.
33 left , =>
34 nonassoc list operators (rightward)
a5f75d66 35 right not
a0d0e21e
LW
36 left and
37 left or xor
38
39In the following sections, these operators are covered in precedence order.
40
cb1a09d0 41=head1 DESCRIPTION
a0d0e21e
LW
42
43=head2 Terms and List Operators (Leftward)
44
54310121 45A TERM has the highest precedence in Perl. They includes variables,
5f05dabc 46quote and quote-like operators, any expression in parentheses,
a0d0e21e
LW
47and any function whose arguments are parenthesized. Actually, there
48aren't really functions in this sense, just list operators and unary
49operators behaving as functions because you put parentheses around
50the arguments. These are all documented in L<perlfunc>.
51
52If any list operator (print(), etc.) or any unary operator (chdir(), etc.)
53is followed by a left parenthesis as the next token, the operator and
54arguments within parentheses are taken to be of highest precedence,
55just like a normal function call.
56
57In the absence of parentheses, the precedence of list operators such as
58C<print>, C<sort>, or C<chmod> is either very high or very low depending on
54310121 59whether you are looking at the left side or the right side of the operator.
a0d0e21e
LW
60For example, in
61
62 @ary = (1, 3, sort 4, 2);
63 print @ary; # prints 1324
64
65the commas on the right of the sort are evaluated before the sort, but
66the commas on the left are evaluated after. In other words, list
67operators tend to gobble up all the arguments that follow them, and
68then act like a simple TERM with regard to the preceding expression.
5f05dabc 69Note that you have to be careful with parentheses:
a0d0e21e
LW
70
71 # These evaluate exit before doing the print:
72 print($foo, exit); # Obviously not what you want.
73 print $foo, exit; # Nor is this.
74
75 # These do the print before evaluating exit:
76 (print $foo), exit; # This is what you want.
77 print($foo), exit; # Or this.
78 print ($foo), exit; # Or even this.
79
80Also note that
81
82 print ($foo & 255) + 1, "\n";
83
54310121 84probably doesn't do what you expect at first glance. See
a0d0e21e
LW
85L<Named Unary Operators> for more discussion of this.
86
87Also parsed as terms are the C<do {}> and C<eval {}> constructs, as
54310121 88well as subroutine and method calls, and the anonymous
a0d0e21e
LW
89constructors C<[]> and C<{}>.
90
2ae324a7 91See also L<Quote and Quote-like Operators> toward the end of this section,
c07a80fd 92as well as L<"I/O Operators">.
a0d0e21e
LW
93
94=head2 The Arrow Operator
95
96Just as in C and C++, "C<-E<gt>>" is an infix dereference operator. If the
97right side is either a C<[...]> or C<{...}> subscript, then the left side
98must be either a hard or symbolic reference to an array or hash (or
99a location capable of holding a hard reference, if it's an lvalue (assignable)).
100See L<perlref>.
101
102Otherwise, the right side is a method name or a simple scalar variable
103containing the method name, and the left side must either be an object
104(a blessed reference) or a class name (that is, a package name).
105See L<perlobj>.
106
5f05dabc 107=head2 Auto-increment and Auto-decrement
a0d0e21e
LW
108
109"++" and "--" work as in C. That is, if placed before a variable, they
110increment or decrement the variable before returning the value, and if
111placed after, increment or decrement the variable after returning the value.
112
54310121 113The auto-increment operator has a little extra builtin magic to it. If
a0d0e21e
LW
114you increment a variable that is numeric, or that has ever been used in
115a numeric context, you get a normal increment. If, however, the
5f05dabc 116variable has been used in only string contexts since it was set, and
a0d0e21e
LW
117has a value that is not null and matches the pattern
118C</^[a-zA-Z]*[0-9]*$/>, the increment is done as a string, preserving each
119character within its range, with carry:
120
121 print ++($foo = '99'); # prints '100'
122 print ++($foo = 'a0'); # prints 'a1'
123 print ++($foo = 'Az'); # prints 'Ba'
124 print ++($foo = 'zz'); # prints 'aaa'
125
5f05dabc 126The auto-decrement operator is not magical.
a0d0e21e
LW
127
128=head2 Exponentiation
129
130Binary "**" is the exponentiation operator. Note that it binds even more
cb1a09d0
AD
131tightly than unary minus, so -2**4 is -(2**4), not (-2)**4. (This is
132implemented using C's pow(3) function, which actually works on doubles
133internally.)
a0d0e21e
LW
134
135=head2 Symbolic Unary Operators
136
5f05dabc 137Unary "!" performs logical negation, i.e., "not". See also C<not> for a lower
a0d0e21e
LW
138precedence version of this.
139
140Unary "-" performs arithmetic negation if the operand is numeric. If
141the operand is an identifier, a string consisting of a minus sign
142concatenated with the identifier is returned. Otherwise, if the string
143starts with a plus or minus, a string starting with the opposite sign
144is returned. One effect of these rules is that C<-bareword> is equivalent
145to C<"-bareword">.
146
5f05dabc 147Unary "~" performs bitwise negation, i.e., 1's complement.
55497cff 148(See also L<Integer Arithmetic>.)
a0d0e21e
LW
149
150Unary "+" has no effect whatsoever, even on strings. It is useful
151syntactically for separating a function name from a parenthesized expression
152that would otherwise be interpreted as the complete list of function
5ba421f6 153arguments. (See examples above under L<Terms and List Operators (Leftward)>.)
a0d0e21e
LW
154
155Unary "\" creates a reference to whatever follows it. See L<perlref>.
156Do not confuse this behavior with the behavior of backslash within a
157string, although both forms do convey the notion of protecting the next
158thing from interpretation.
159
160=head2 Binding Operators
161
c07a80fd 162Binary "=~" binds a scalar expression to a pattern match. Certain operations
cb1a09d0
AD
163search or modify the string $_ by default. This operator makes that kind
164of operation work on some other string. The right argument is a search
165pattern, substitution, or translation. The left argument is what is
166supposed to be searched, substituted, or translated instead of the default
167$_. The return value indicates the success of the operation. (If the
168right argument is an expression rather than a search pattern,
169substitution, or translation, it is interpreted as a search pattern at run
aa689395
PP
170time. This can be is less efficient than an explicit search, because the
171pattern must be compiled every time the expression is evaluated.
a0d0e21e
LW
172
173Binary "!~" is just like "=~" except the return value is negated in
174the logical sense.
175
176=head2 Multiplicative Operators
177
178Binary "*" multiplies two numbers.
179
180Binary "/" divides two numbers.
181
54310121
PP
182Binary "%" computes the modulus of two numbers. Given integer
183operands C<$a> and C<$b>: If C<$b> is positive, then C<$a % $b> is
184C<$a> minus the largest multiple of C<$b> that is not greater than
185C<$a>. If C<$b> is negative, then C<$a % $b> is C<$a> minus the
186smallest multiple of C<$b> that is not less than C<$a> (i.e. the
187result will be less than or equal to zero).
a0d0e21e
LW
188
189Binary "x" is the repetition operator. In a scalar context, it
190returns a string consisting of the left operand repeated the number of
191times specified by the right operand. In a list context, if the left
5f05dabc 192operand is a list in parentheses, it repeats the list.
a0d0e21e
LW
193
194 print '-' x 80; # print row of dashes
195
196 print "\t" x ($tab/8), ' ' x ($tab%8); # tab over
197
198 @ones = (1) x 80; # a list of 80 1's
199 @ones = (5) x @ones; # set all elements to 5
200
201
202=head2 Additive Operators
203
204Binary "+" returns the sum of two numbers.
205
206Binary "-" returns the difference of two numbers.
207
208Binary "." concatenates two strings.
209
210=head2 Shift Operators
211
55497cff
PP
212Binary "<<" returns the value of its left argument shifted left by the
213number of bits specified by the right argument. Arguments should be
214integers. (See also L<Integer Arithmetic>.)
a0d0e21e 215
55497cff
PP
216Binary ">>" returns the value of its left argument shifted right by
217the number of bits specified by the right argument. Arguments should
218be integers. (See also L<Integer Arithmetic>.)
a0d0e21e
LW
219
220=head2 Named Unary Operators
221
222The various named unary operators are treated as functions with one
223argument, with optional parentheses. These include the filetest
224operators, like C<-f>, C<-M>, etc. See L<perlfunc>.
225
226If any list operator (print(), etc.) or any unary operator (chdir(), etc.)
227is followed by a left parenthesis as the next token, the operator and
228arguments within parentheses are taken to be of highest precedence,
229just like a normal function call. Examples:
230
231 chdir $foo || die; # (chdir $foo) || die
232 chdir($foo) || die; # (chdir $foo) || die
233 chdir ($foo) || die; # (chdir $foo) || die
234 chdir +($foo) || die; # (chdir $foo) || die
235
236but, because * is higher precedence than ||:
237
238 chdir $foo * 20; # chdir ($foo * 20)
239 chdir($foo) * 20; # (chdir $foo) * 20
240 chdir ($foo) * 20; # (chdir $foo) * 20
241 chdir +($foo) * 20; # chdir ($foo * 20)
242
243 rand 10 * 20; # rand (10 * 20)
244 rand(10) * 20; # (rand 10) * 20
245 rand (10) * 20; # (rand 10) * 20
246 rand +(10) * 20; # rand (10 * 20)
247
5ba421f6 248See also L<"Terms and List Operators (Leftward)">.
a0d0e21e
LW
249
250=head2 Relational Operators
251
6ee5d4e7 252Binary "E<lt>" returns true if the left argument is numerically less than
a0d0e21e
LW
253the right argument.
254
6ee5d4e7 255Binary "E<gt>" returns true if the left argument is numerically greater
a0d0e21e
LW
256than the right argument.
257
6ee5d4e7 258Binary "E<lt>=" returns true if the left argument is numerically less than
a0d0e21e
LW
259or equal to the right argument.
260
6ee5d4e7 261Binary "E<gt>=" returns true if the left argument is numerically greater
a0d0e21e
LW
262than or equal to the right argument.
263
264Binary "lt" returns true if the left argument is stringwise less than
265the right argument.
266
267Binary "gt" returns true if the left argument is stringwise greater
268than the right argument.
269
270Binary "le" returns true if the left argument is stringwise less than
271or equal to the right argument.
272
273Binary "ge" returns true if the left argument is stringwise greater
274than or equal to the right argument.
275
276=head2 Equality Operators
277
278Binary "==" returns true if the left argument is numerically equal to
279the right argument.
280
281Binary "!=" returns true if the left argument is numerically not equal
282to the right argument.
283
6ee5d4e7
PP
284Binary "E<lt>=E<gt>" returns -1, 0, or 1 depending on whether the left
285argument is numerically less than, equal to, or greater than the right
286argument.
a0d0e21e
LW
287
288Binary "eq" returns true if the left argument is stringwise equal to
289the right argument.
290
291Binary "ne" returns true if the left argument is stringwise not equal
292to the right argument.
293
294Binary "cmp" returns -1, 0, or 1 depending on whether the left argument is stringwise
295less than, equal to, or greater than the right argument.
296
a034a98d
DD
297"lt", "le", "ge", "gt" and "cmp" use the collation (sort) order specified
298by the current locale if C<use locale> is in effect. See L<perllocale>.
299
a0d0e21e
LW
300=head2 Bitwise And
301
302Binary "&" returns its operators ANDed together bit by bit.
55497cff 303(See also L<Integer Arithmetic>.)
a0d0e21e
LW
304
305=head2 Bitwise Or and Exclusive Or
306
307Binary "|" returns its operators ORed together bit by bit.
55497cff 308(See also L<Integer Arithmetic>.)
a0d0e21e
LW
309
310Binary "^" returns its operators XORed together bit by bit.
55497cff 311(See also L<Integer Arithmetic>.)
a0d0e21e
LW
312
313=head2 C-style Logical And
314
315Binary "&&" performs a short-circuit logical AND operation. That is,
316if the left operand is false, the right operand is not even evaluated.
317Scalar or list context propagates down to the right operand if it
318is evaluated.
319
320=head2 C-style Logical Or
321
322Binary "||" performs a short-circuit logical OR operation. That is,
323if the left operand is true, the right operand is not even evaluated.
324Scalar or list context propagates down to the right operand if it
325is evaluated.
326
327The C<||> and C<&&> operators differ from C's in that, rather than returning
3280 or 1, they return the last value evaluated. Thus, a reasonably portable
329way to find out the home directory (assuming it's not "0") might be:
330
331 $home = $ENV{'HOME'} || $ENV{'LOGDIR'} ||
332 (getpwuid($<))[7] || die "You're homeless!\n";
333
334As more readable alternatives to C<&&> and C<||>, Perl provides "and" and
335"or" operators (see below). The short-circuit behavior is identical. The
336precedence of "and" and "or" is much lower, however, so that you can
337safely use them after a list operator without the need for
338parentheses:
339
340 unlink "alpha", "beta", "gamma"
341 or gripe(), next LINE;
342
343With the C-style operators that would have been written like this:
344
345 unlink("alpha", "beta", "gamma")
346 || (gripe(), next LINE);
347
348=head2 Range Operator
349
350Binary ".." is the range operator, which is really two different
351operators depending on the context. In a list context, it returns an
352array of values counting (by ones) from the left value to the right
353value. This is useful for writing C<for (1..10)> loops and for doing
354slice operations on arrays. Be aware that under the current implementation,
54310121 355a temporary array is created, so you'll burn a lot of memory if you
a0d0e21e
LW
356write something like this:
357
358 for (1 .. 1_000_000) {
359 # code
54310121 360 }
a0d0e21e
LW
361
362In a scalar context, ".." returns a boolean value. The operator is
363bistable, like a flip-flop, and emulates the line-range (comma) operator
364of B<sed>, B<awk>, and various editors. Each ".." operator maintains its
365own boolean state. It is false as long as its left operand is false.
366Once the left operand is true, the range operator stays true until the
367right operand is true, I<AFTER> which the range operator becomes false
368again. (It doesn't become false till the next time the range operator is
369evaluated. It can test the right operand and become false on the same
370evaluation it became true (as in B<awk>), but it still returns true once.
371If you don't want it to test the right operand till the next evaluation
372(as in B<sed>), use three dots ("...") instead of two.) The right
373operand is not evaluated while the operator is in the "false" state, and
374the left operand is not evaluated while the operator is in the "true"
375state. The precedence is a little lower than || and &&. The value
376returned is either the null string for false, or a sequence number
377(beginning with 1) for true. The sequence number is reset for each range
378encountered. The final sequence number in a range has the string "E0"
379appended to it, which doesn't affect its numeric value, but gives you
380something to search for if you want to exclude the endpoint. You can
381exclude the beginning point by waiting for the sequence number to be
382greater than 1. If either operand of scalar ".." is a numeric literal,
383that operand is implicitly compared to the C<$.> variable, the current
384line number. Examples:
385
386As a scalar operator:
387
388 if (101 .. 200) { print; } # print 2nd hundred lines
389 next line if (1 .. /^$/); # skip header lines
390 s/^/> / if (/^$/ .. eof()); # quote body
391
392As a list operator:
393
394 for (101 .. 200) { print; } # print $_ 100 times
3e3baf6d 395 @foo = @foo[0 .. $#foo]; # an expensive no-op
a0d0e21e
LW
396 @foo = @foo[$#foo-4 .. $#foo]; # slice last 5 items
397
398The range operator (in a list context) makes use of the magical
5f05dabc 399auto-increment algorithm if the operands are strings. You
a0d0e21e
LW
400can say
401
402 @alphabet = ('A' .. 'Z');
403
404to get all the letters of the alphabet, or
405
406 $hexdigit = (0 .. 9, 'a' .. 'f')[$num & 15];
407
408to get a hexadecimal digit, or
409
410 @z2 = ('01' .. '31'); print $z2[$mday];
411
412to get dates with leading zeros. If the final value specified is not
413in the sequence that the magical increment would produce, the sequence
414goes until the next value would be longer than the final value
415specified.
416
417=head2 Conditional Operator
418
419Ternary "?:" is the conditional operator, just as in C. It works much
420like an if-then-else. If the argument before the ? is true, the
421argument before the : is returned, otherwise the argument after the :
cb1a09d0
AD
422is returned. For example:
423
54310121 424 printf "I have %d dog%s.\n", $n,
cb1a09d0
AD
425 ($n == 1) ? '' : "s";
426
427Scalar or list context propagates downward into the 2nd
54310121 428or 3rd argument, whichever is selected.
cb1a09d0
AD
429
430 $a = $ok ? $b : $c; # get a scalar
431 @a = $ok ? @b : @c; # get an array
432 $a = $ok ? @b : @c; # oops, that's just a count!
433
434The operator may be assigned to if both the 2nd and 3rd arguments are
435legal lvalues (meaning that you can assign to them):
a0d0e21e
LW
436
437 ($a_or_b ? $a : $b) = $c;
438
cb1a09d0 439This is not necessarily guaranteed to contribute to the readability of your program.
a0d0e21e 440
4633a7c4 441=head2 Assignment Operators
a0d0e21e
LW
442
443"=" is the ordinary assignment operator.
444
445Assignment operators work as in C. That is,
446
447 $a += 2;
448
449is equivalent to
450
451 $a = $a + 2;
452
453although without duplicating any side effects that dereferencing the lvalue
54310121
PP
454might trigger, such as from tie(). Other assignment operators work similarly.
455The following are recognized:
a0d0e21e
LW
456
457 **= += *= &= <<= &&=
458 -= /= |= >>= ||=
459 .= %= ^=
460 x=
461
462Note that while these are grouped by family, they all have the precedence
463of assignment.
464
465Unlike in C, the assignment operator produces a valid lvalue. Modifying
466an assignment is equivalent to doing the assignment and then modifying
467the variable that was assigned to. This is useful for modifying
468a copy of something, like this:
469
470 ($tmp = $global) =~ tr [A-Z] [a-z];
471
472Likewise,
473
474 ($a += 2) *= 3;
475
476is equivalent to
477
478 $a += 2;
479 $a *= 3;
480
748a9306 481=head2 Comma Operator
a0d0e21e
LW
482
483Binary "," is the comma operator. In a scalar context it evaluates
484its left argument, throws that value away, then evaluates its right
485argument and returns that value. This is just like C's comma operator.
486
487In a list context, it's just the list argument separator, and inserts
488both its arguments into the list.
489
6ee5d4e7 490The =E<gt> digraph is mostly just a synonym for the comma operator. It's useful for
cb1a09d0 491documenting arguments that come in pairs. As of release 5.001, it also forces
4633a7c4 492any word to the left of it to be interpreted as a string.
748a9306 493
a0d0e21e
LW
494=head2 List Operators (Rightward)
495
496On the right side of a list operator, it has very low precedence,
497such that it controls all comma-separated expressions found there.
498The only operators with lower precedence are the logical operators
499"and", "or", and "not", which may be used to evaluate calls to list
500operators without the need for extra parentheses:
501
502 open HANDLE, "filename"
503 or die "Can't open: $!\n";
504
5ba421f6 505See also discussion of list operators in L<Terms and List Operators (Leftward)>.
a0d0e21e
LW
506
507=head2 Logical Not
508
509Unary "not" returns the logical negation of the expression to its right.
510It's the equivalent of "!" except for the very low precedence.
511
512=head2 Logical And
513
514Binary "and" returns the logical conjunction of the two surrounding
515expressions. It's equivalent to && except for the very low
5f05dabc 516precedence. This means that it short-circuits: i.e., the right
a0d0e21e
LW
517expression is evaluated only if the left expression is true.
518
519=head2 Logical or and Exclusive Or
520
521Binary "or" returns the logical disjunction of the two surrounding
522expressions. It's equivalent to || except for the very low
5f05dabc 523precedence. This means that it short-circuits: i.e., the right
a0d0e21e
LW
524expression is evaluated only if the left expression is false.
525
526Binary "xor" returns the exclusive-OR of the two surrounding expressions.
527It cannot short circuit, of course.
528
529=head2 C Operators Missing From Perl
530
531Here is what C has that Perl doesn't:
532
533=over 8
534
535=item unary &
536
537Address-of operator. (But see the "\" operator for taking a reference.)
538
539=item unary *
540
54310121 541Dereference-address operator. (Perl's prefix dereferencing
a0d0e21e
LW
542operators are typed: $, @, %, and &.)
543
544=item (TYPE)
545
54310121 546Type casting operator.
a0d0e21e
LW
547
548=back
549
5f05dabc 550=head2 Quote and Quote-like Operators
a0d0e21e
LW
551
552While we usually think of quotes as literal values, in Perl they
553function as operators, providing various kinds of interpolating and
554pattern matching capabilities. Perl provides customary quote characters
555for these behaviors, but also provides a way for you to choose your
556quote character for any of them. In the following table, a C<{}> represents
557any pair of delimiters you choose. Non-bracketing delimiters use
54310121 558the same character fore and aft, but the 4 sorts of brackets
a0d0e21e
LW
559(round, angle, square, curly) will all nest.
560
561 Customary Generic Meaning Interpolates
562 '' q{} Literal no
563 "" qq{} Literal yes
564 `` qx{} Command yes
565 qw{} Word list no
566 // m{} Pattern match yes
567 s{}{} Substitution yes
568 tr{}{} Translation no
569
fb73857a
PP
570Note that there can be whitespace between the operator and the quoting
571characters, except when C<#> is being used as the quoting character.
572C<q#foo#> is parsed as being the string C<foo>, which C<q #foo#> is the
573operator C<q> followed by a comment. Its argument will be taken from the
574next line. This allows you to write:
575
576 s {foo} # Replace foo
577 {bar} # with bar.
578
cb1a09d0 579For constructs that do interpolation, variables beginning with "C<$>" or "C<@>"
a0d0e21e
LW
580are interpolated, as are the following sequences:
581
6ee5d4e7
PP
582 \t tab (HT, TAB)
583 \n newline (LF, NL)
584 \r return (CR)
585 \f form feed (FF)
586 \b backspace (BS)
587 \a alarm (bell) (BEL)
588 \e escape (ESC)
a0d0e21e
LW
589 \033 octal char
590 \x1b hex char
591 \c[ control char
592 \l lowercase next char
593 \u uppercase next char
594 \L lowercase till \E
595 \U uppercase till \E
596 \E end case modification
597 \Q quote regexp metacharacters till \E
598
a034a98d
DD
599If C<use locale> is in effect, the case map used by C<\l>, C<\L>, C<\u>
600and <\U> is taken from the current locale. See L<perllocale>.
601
a0d0e21e
LW
602Patterns are subject to an additional level of interpretation as a
603regular expression. This is done as a second pass, after variables are
604interpolated, so that regular expressions may be incorporated into the
605pattern from the variables. If this is not what you want, use C<\Q> to
606interpolate a variable literally.
607
608Apart from the above, there are no multiple levels of interpolation. In
5f05dabc 609particular, contrary to the expectations of shell programmers, back-quotes
a0d0e21e
LW
610do I<NOT> interpolate within double quotes, nor do single quotes impede
611evaluation of variables when used within double quotes.
612
5f05dabc 613=head2 Regexp Quote-Like Operators
cb1a09d0 614
5f05dabc 615Here are the quote-like operators that apply to pattern
cb1a09d0
AD
616matching and related activities.
617
a0d0e21e
LW
618=over 8
619
620=item ?PATTERN?
621
622This is just like the C</pattern/> search, except that it matches only
623once between calls to the reset() operator. This is a useful
5f05dabc 624optimization when you want to see only the first occurrence of
a0d0e21e
LW
625something in each file of a set of files, for instance. Only C<??>
626patterns local to the current package are reset.
627
628This usage is vaguely deprecated, and may be removed in some future
629version of Perl.
630
fb73857a 631=item m/PATTERN/cgimosx
a0d0e21e 632
fb73857a 633=item /PATTERN/cgimosx
a0d0e21e
LW
634
635Searches a string for a pattern match, and in a scalar context returns
636true (1) or false (''). If no string is specified via the C<=~> or
637C<!~> operator, the $_ string is searched. (The string specified with
638C<=~> need not be an lvalue--it may be the result of an expression
639evaluation, but remember the C<=~> binds rather tightly.) See also
640L<perlre>.
a034a98d
DD
641See L<perllocale> for discussion of additional considerations which apply
642when C<use locale> is in effect.
a0d0e21e
LW
643
644Options are:
645
fb73857a 646 c Do not reset search position on a failed match when /g is in effect.
5f05dabc 647 g Match globally, i.e., find all occurrences.
a0d0e21e
LW
648 i Do case-insensitive pattern matching.
649 m Treat string as multiple lines.
5f05dabc 650 o Compile pattern only once.
a0d0e21e
LW
651 s Treat string as single line.
652 x Use extended regular expressions.
653
654If "/" is the delimiter then the initial C<m> is optional. With the C<m>
655you can use any pair of non-alphanumeric, non-whitespace characters as
656delimiters. This is particularly useful for matching Unix path names
7bac28a0
PP
657that contain "/", to avoid LTS (leaning toothpick syndrome). If "?" is
658the delimiter, then the match-only-once rule of C<?PATTERN?> applies.
a0d0e21e
LW
659
660PATTERN may contain variables, which will be interpolated (and the
661pattern recompiled) every time the pattern search is evaluated. (Note
662that C<$)> and C<$|> might not be interpolated because they look like
663end-of-string tests.) If you want such a pattern to be compiled only
664once, add a C</o> after the trailing delimiter. This avoids expensive
665run-time recompilations, and is useful when the value you are
666interpolating won't change over the life of the script. However, mentioning
667C</o> constitutes a promise that you won't change the variables in the pattern.
668If you change them, Perl won't even notice.
669
4633a7c4
LW
670If the PATTERN evaluates to a null string, the last
671successfully executed regular expression is used instead.
a0d0e21e
LW
672
673If used in a context that requires a list value, a pattern match returns a
674list consisting of the subexpressions matched by the parentheses in the
5f05dabc 675pattern, i.e., (C<$1>, $2, $3...). (Note that here $1 etc. are also set, and
a0d0e21e
LW
676that this differs from Perl 4's behavior.) If the match fails, a null
677array is returned. If the match succeeds, but there were no parentheses,
678a list value of (1) is returned.
679
680Examples:
681
682 open(TTY, '/dev/tty');
683 <TTY> =~ /^y/i && foo(); # do foo if desired
684
685 if (/Version: *([0-9.]*)/) { $version = $1; }
686
687 next if m#^/usr/spool/uucp#;
688
689 # poor man's grep
690 $arg = shift;
691 while (<>) {
692 print if /$arg/o; # compile only once
693 }
694
695 if (($F1, $F2, $Etc) = ($foo =~ /^(\S+)\s+(\S+)\s*(.*)/))
696
697This last example splits $foo into the first two words and the
5f05dabc
PP
698remainder of the line, and assigns those three fields to $F1, $F2, and
699$Etc. The conditional is true if any variables were assigned, i.e., if
a0d0e21e
LW
700the pattern matched.
701
702The C</g> modifier specifies global pattern matching--that is, matching
703as many times as possible within the string. How it behaves depends on
704the context. In a list context, it returns a list of all the
705substrings matched by all the parentheses in the regular expression.
706If there are no parentheses, it returns a list of all the matched
707strings, as if there were parentheses around the whole pattern.
708
709In a scalar context, C<m//g> iterates through the string, returning TRUE
c90c0ff4
PP
710each time it matches, and FALSE when it eventually runs out of matches.
711(In other words, it remembers where it left off last time and restarts
712the search at that point. You can actually find the current match
713position of a string or set it using the pos() function; see
714L<perlfunc/pos>.) A failed match normally resets the search position to
90248788 715the beginning of the string, but you can avoid that by adding the C</c>
c90c0ff4
PP
716modifier (e.g. C<m//gc>). Modifying the target string also resets the
717search position.
718
719You can intermix C<m//g> matches with C<m/\G.../g>, where C<\G> is a
720zero-width assertion that matches the exact position where the previous
721C<m//g>, if any, left off. The C<\G> assertion is not supported without
722the C</g> modifier; currently, without C</g>, C<\G> behaves just like
723C<\A>, but that's accidental and may change in the future.
724
725Examples:
a0d0e21e
LW
726
727 # list context
728 ($one,$five,$fifteen) = (`uptime` =~ /(\d+\.\d+)/g);
729
730 # scalar context
5f05dabc 731 $/ = ""; $* = 1; # $* deprecated in modern perls
54310121 732 while (defined($paragraph = <>)) {
a0d0e21e
LW
733 while ($paragraph =~ /[a-z]['")]*[.!?]+['")]*\s/g) {
734 $sentences++;
735 }
736 }
737 print "$sentences\n";
738
c90c0ff4 739 # using m//gc with \G
137443ea 740 $_ = "ppooqppqq";
44a8e56a
PP
741 while ($i++ < 2) {
742 print "1: '";
c90c0ff4 743 print $1 while /(o)/gc; print "', pos=", pos, "\n";
44a8e56a 744 print "2: '";
c90c0ff4 745 print $1 if /\G(q)/gc; print "', pos=", pos, "\n";
44a8e56a 746 print "3: '";
c90c0ff4 747 print $1 while /(p)/gc; print "', pos=", pos, "\n";
44a8e56a
PP
748 }
749
750The last example should print:
751
752 1: 'oo', pos=4
137443ea 753 2: 'q', pos=5
44a8e56a
PP
754 3: 'pp', pos=7
755 1: '', pos=7
137443ea
PP
756 2: 'q', pos=8
757 3: '', pos=8
44a8e56a 758
c90c0ff4 759A useful idiom for C<lex>-like scanners is C</\G.../gc>. You can
e7ea3e70 760combine several regexps like this to process a string part-by-part,
c90c0ff4
PP
761doing different actions depending on which regexp matched. Each
762regexp tries to match where the previous one leaves off.
e7ea3e70 763
3fe9a6f1 764 $_ = <<'EOL';
e7ea3e70 765 $url = new URI::URL "http://www/"; die if $url eq "xXx";
3fe9a6f1
PP
766 EOL
767 LOOP:
e7ea3e70 768 {
c90c0ff4
PP
769 print(" digits"), redo LOOP if /\G\d+\b[,.;]?\s*/gc;
770 print(" lowercase"), redo LOOP if /\G[a-z]+\b[,.;]?\s*/gc;
771 print(" UPPERCASE"), redo LOOP if /\G[A-Z]+\b[,.;]?\s*/gc;
772 print(" Capitalized"), redo LOOP if /\G[A-Z][a-z]+\b[,.;]?\s*/gc;
773 print(" MiXeD"), redo LOOP if /\G[A-Za-z]+\b[,.;]?\s*/gc;
774 print(" alphanumeric"), redo LOOP if /\G[A-Za-z0-9]+\b[,.;]?\s*/gc;
775 print(" line-noise"), redo LOOP if /\G[^A-Za-z0-9]+/gc;
e7ea3e70
IZ
776 print ". That's all!\n";
777 }
778
779Here is the output (split into several lines):
780
781 line-noise lowercase line-noise lowercase UPPERCASE line-noise
782 UPPERCASE line-noise lowercase line-noise lowercase line-noise
783 lowercase lowercase line-noise lowercase lowercase line-noise
784 MiXeD line-noise. That's all!
44a8e56a 785
a0d0e21e
LW
786=item q/STRING/
787
788=item C<'STRING'>
789
68dc0745
PP
790A single-quoted, literal string. A backslash represents a backslash
791unless followed by the delimiter or another backslash, in which case
792the delimiter or backslash is interpolated.
a0d0e21e
LW
793
794 $foo = q!I said, "You said, 'She said it.'"!;
795 $bar = q('This is it.');
68dc0745 796 $baz = '\n'; # a two-character string
a0d0e21e
LW
797
798=item qq/STRING/
799
800=item "STRING"
801
802A double-quoted, interpolated string.
803
804 $_ .= qq
805 (*** The previous line contains the naughty word "$1".\n)
806 if /(tcl|rexx|python)/; # :-)
68dc0745 807 $baz = "\n"; # a one-character string
a0d0e21e
LW
808
809=item qx/STRING/
810
811=item `STRING`
812
813A string which is interpolated and then executed as a system command.
814The collected standard output of the command is returned. In scalar
4a6725af 815context, it comes back as a single (potentially multi-line) string.
a0d0e21e
LW
816In list context, returns a list of lines (however you've defined lines
817with $/ or $INPUT_RECORD_SEPARATOR).
818
819 $today = qx{ date };
820
bb32b41a
GS
821Note that how the string gets evaluated is entirely subject to the
822command interpreter on your system. On most platforms, you will have
823to protect shell metacharacters if you want them treated literally.
824On some platforms (notably DOS-like ones), the shell may not be
825capable of dealing with multiline commands, so putting newlines in
826the string may not get you what you want. You may be able to evaluate
827multiple commands in a single line by separating them with the command
828separator character, if your shell supports that (e.g. C<;> on many Unix
829shells; C<&> on the Windows NT C<cmd> shell).
830
831Beware that some command shells may place restrictions on the length
832of the command line. You must ensure your strings don't exceed this
833limit after any necessary interpolations. See the platform-specific
834release notes for more details about your particular environment.
835
836Also realize that using this operator frequently leads to unportable
837programs.
838
dc848c6f 839See L<"I/O Operators"> for more discussion.
a0d0e21e
LW
840
841=item qw/STRING/
842
843Returns a list of the words extracted out of STRING, using embedded
844whitespace as the word delimiters. It is exactly equivalent to
845
846 split(' ', q/STRING/);
847
848Some frequently seen examples:
849
850 use POSIX qw( setlocale localeconv )
851 @EXPORT = qw( foo bar baz );
852
7bac28a0
PP
853A common mistake is to try to separate the words with comma or to put
854comments into a multi-line qw-string. For this reason the C<-w>
855switch produce warnings if the STRING contains the "," or the "#"
856character.
857
a0d0e21e
LW
858=item s/PATTERN/REPLACEMENT/egimosx
859
860Searches a string for a pattern, and if found, replaces that pattern
861with the replacement text and returns the number of substitutions
e37d713d 862made. Otherwise it returns false (specifically, the empty string).
a0d0e21e
LW
863
864If no string is specified via the C<=~> or C<!~> operator, the C<$_>
865variable is searched and modified. (The string specified with C<=~> must
866be a scalar variable, an array element, a hash element, or an assignment
5f05dabc 867to one of those, i.e., an lvalue.)
a0d0e21e
LW
868
869If the delimiter chosen is single quote, no variable interpolation is
870done on either the PATTERN or the REPLACEMENT. Otherwise, if the
871PATTERN contains a $ that looks like a variable rather than an
872end-of-string test, the variable will be interpolated into the pattern
5f05dabc 873at run-time. If you want the pattern compiled only once the first time
a0d0e21e 874the variable is interpolated, use the C</o> option. If the pattern
4633a7c4 875evaluates to a null string, the last successfully executed regular
a0d0e21e 876expression is used instead. See L<perlre> for further explanation on these.
a034a98d
DD
877See L<perllocale> for discussion of additional considerations which apply
878when C<use locale> is in effect.
a0d0e21e
LW
879
880Options are:
881
882 e Evaluate the right side as an expression.
5f05dabc 883 g Replace globally, i.e., all occurrences.
a0d0e21e
LW
884 i Do case-insensitive pattern matching.
885 m Treat string as multiple lines.
5f05dabc 886 o Compile pattern only once.
a0d0e21e
LW
887 s Treat string as single line.
888 x Use extended regular expressions.
889
890Any non-alphanumeric, non-whitespace delimiter may replace the
891slashes. If single quotes are used, no interpretation is done on the
e37d713d 892replacement string (the C</e> modifier overrides this, however). Unlike
54310121 893Perl 4, Perl 5 treats backticks as normal delimiters; the replacement
e37d713d 894text is not evaluated as a command. If the
a0d0e21e 895PATTERN is delimited by bracketing quotes, the REPLACEMENT has its own
5f05dabc 896pair of quotes, which may or may not be bracketing quotes, e.g.,
a0d0e21e
LW
897C<s(foo)(bar)> or C<sE<lt>fooE<gt>/bar/>. A C</e> will cause the
898replacement portion to be interpreter as a full-fledged Perl expression
899and eval()ed right then and there. It is, however, syntax checked at
900compile-time.
901
902Examples:
903
904 s/\bgreen\b/mauve/g; # don't change wintergreen
905
906 $path =~ s|/usr/bin|/usr/local/bin|;
907
908 s/Login: $foo/Login: $bar/; # run-time pattern
909
910 ($foo = $bar) =~ s/this/that/;
911
912 $count = ($paragraph =~ s/Mister\b/Mr./g);
913
914 $_ = 'abc123xyz';
915 s/\d+/$&*2/e; # yields 'abc246xyz'
916 s/\d+/sprintf("%5d",$&)/e; # yields 'abc 246xyz'
917 s/\w/$& x 2/eg; # yields 'aabbcc 224466xxyyzz'
918
919 s/%(.)/$percent{$1}/g; # change percent escapes; no /e
920 s/%(.)/$percent{$1} || $&/ge; # expr now, so /e
921 s/^=(\w+)/&pod($1)/ge; # use function call
922
923 # /e's can even nest; this will expand
924 # simple embedded variables in $_
925 s/(\$\w+)/$1/eeg;
926
927 # Delete C comments.
928 $program =~ s {
4633a7c4
LW
929 /\* # Match the opening delimiter.
930 .*? # Match a minimal number of characters.
931 \*/ # Match the closing delimiter.
a0d0e21e
LW
932 } []gsx;
933
934 s/^\s*(.*?)\s*$/$1/; # trim white space
935
936 s/([^ ]*) *([^ ]*)/$2 $1/; # reverse 1st two fields
937
54310121 938Note the use of $ instead of \ in the last example. Unlike
5f05dabc 939B<sed>, we use the \E<lt>I<digit>E<gt> form in only the left hand side.
6ee5d4e7 940Anywhere else it's $E<lt>I<digit>E<gt>.
a0d0e21e 941
5f05dabc 942Occasionally, you can't use just a C</g> to get all the changes
a0d0e21e
LW
943to occur. Here are two common cases:
944
945 # put commas in the right places in an integer
946 1 while s/(.*\d)(\d\d\d)/$1,$2/g; # perl4
947 1 while s/(\d)(\d\d\d)(?!\d)/$1,$2/g; # perl5
948
949 # expand tabs to 8-column spacing
950 1 while s/\t+/' ' x (length($&)*8 - length($`)%8)/e;
951
952
953=item tr/SEARCHLIST/REPLACEMENTLIST/cds
954
955=item y/SEARCHLIST/REPLACEMENTLIST/cds
956
957Translates all occurrences of the characters found in the search list
958with the corresponding character in the replacement list. It returns
959the number of characters replaced or deleted. If no string is
960specified via the =~ or !~ operator, the $_ string is translated. (The
54310121
PP
961string specified with =~ must be a scalar variable, an array element, a
962hash element, or an assignment to one of those, i.e., an lvalue.)
963For B<sed> devotees, C<y> is provided as a synonym for C<tr>. If the
964SEARCHLIST is delimited by bracketing quotes, the REPLACEMENTLIST has
965its own pair of quotes, which may or may not be bracketing quotes,
966e.g., C<tr[A-Z][a-z]> or C<tr(+-*/)/ABCD/>.
a0d0e21e
LW
967
968Options:
969
970 c Complement the SEARCHLIST.
971 d Delete found but unreplaced characters.
972 s Squash duplicate replaced characters.
973
974If the C</c> modifier is specified, the SEARCHLIST character set is
975complemented. If the C</d> modifier is specified, any characters specified
976by SEARCHLIST not found in REPLACEMENTLIST are deleted. (Note
977that this is slightly more flexible than the behavior of some B<tr>
978programs, which delete anything they find in the SEARCHLIST, period.)
979If the C</s> modifier is specified, sequences of characters that were
980translated to the same character are squashed down to a single instance of the
981character.
982
983If the C</d> modifier is used, the REPLACEMENTLIST is always interpreted
984exactly as specified. Otherwise, if the REPLACEMENTLIST is shorter
985than the SEARCHLIST, the final character is replicated till it is long
986enough. If the REPLACEMENTLIST is null, the SEARCHLIST is replicated.
987This latter is useful for counting characters in a class or for
988squashing character sequences in a class.
989
990Examples:
991
992 $ARGV[1] =~ tr/A-Z/a-z/; # canonicalize to lower case
993
994 $cnt = tr/*/*/; # count the stars in $_
995
996 $cnt = $sky =~ tr/*/*/; # count the stars in $sky
997
998 $cnt = tr/0-9//; # count the digits in $_
999
1000 tr/a-zA-Z//s; # bookkeeper -> bokeper
1001
1002 ($HOST = $host) =~ tr/a-z/A-Z/;
1003
1004 tr/a-zA-Z/ /cs; # change non-alphas to single space
1005
1006 tr [\200-\377]
1007 [\000-\177]; # delete 8th bit
1008
748a9306
LW
1009If multiple translations are given for a character, only the first one is used:
1010
1011 tr/AAA/XYZ/
1012
1013will translate any A to X.
1014
a0d0e21e
LW
1015Note that because the translation table is built at compile time, neither
1016the SEARCHLIST nor the REPLACEMENTLIST are subjected to double quote
1017interpolation. That means that if you want to use variables, you must use
1018an eval():
1019
1020 eval "tr/$oldlist/$newlist/";
1021 die $@ if $@;
1022
1023 eval "tr/$oldlist/$newlist/, 1" or die $@;
1024
1025=back
1026
1027=head2 I/O Operators
1028
54310121
PP
1029There are several I/O operators you should know about.
1030A string is enclosed by backticks (grave accents) first undergoes
a0d0e21e
LW
1031variable substitution just like a double quoted string. It is then
1032interpreted as a command, and the output of that command is the value
1033of the pseudo-literal, like in a shell. In a scalar context, a single
1034string consisting of all the output is returned. In a list context,
1035a list of values is returned, one for each line of output. (You can
1036set C<$/> to use a different line terminator.) The command is executed
1037each time the pseudo-literal is evaluated. The status value of the
1038command is returned in C<$?> (see L<perlvar> for the interpretation
1039of C<$?>). Unlike in B<csh>, no translation is done on the return
1040data--newlines remain newlines. Unlike in any of the shells, single
1041quotes do not hide variable names in the command from interpretation.
1042To pass a $ through to the shell you need to hide it with a backslash.
54310121
PP
1043The generalized form of backticks is C<qx//>. (Because backticks
1044always undergo shell expansion as well, see L<perlsec> for
cb1a09d0 1045security concerns.)
a0d0e21e
LW
1046
1047Evaluating a filehandle in angle brackets yields the next line from
aa689395
PP
1048that file (newline, if any, included), or C<undef> at end of file.
1049Ordinarily you must assign that value to a variable, but there is one
1050situation where an automatic assignment happens. I<If and ONLY if> the
1051input symbol is the only thing inside the conditional of a C<while> or
1052C<for(;;)> loop, the value is automatically assigned to the variable
1053C<$_>. The assigned value is then tested to see if it is defined.
1054(This may seem like an odd thing to you, but you'll use the construct
1055in almost every Perl script you write.) Anyway, the following lines
1056are equivalent to each other:
a0d0e21e 1057
748a9306 1058 while (defined($_ = <STDIN>)) { print; }
a0d0e21e
LW
1059 while (<STDIN>) { print; }
1060 for (;<STDIN>;) { print; }
748a9306 1061 print while defined($_ = <STDIN>);
a0d0e21e
LW
1062 print while <STDIN>;
1063
5f05dabc
PP
1064The filehandles STDIN, STDOUT, and STDERR are predefined. (The
1065filehandles C<stdin>, C<stdout>, and C<stderr> will also work except in
a0d0e21e
LW
1066packages, where they would be interpreted as local identifiers rather
1067than global.) Additional filehandles may be created with the open()
cb1a09d0 1068function. See L<perlfunc/open()> for details on this.
a0d0e21e 1069
6ee5d4e7 1070If a E<lt>FILEHANDLEE<gt> is used in a context that is looking for a list, a
a0d0e21e
LW
1071list consisting of all the input lines is returned, one line per list
1072element. It's easy to make a I<LARGE> data space this way, so use with
1073care.
1074
d28ebecd
PP
1075The null filehandle E<lt>E<gt> is special and can be used to emulate the
1076behavior of B<sed> and B<awk>. Input from E<lt>E<gt> comes either from
a0d0e21e 1077standard input, or from each file listed on the command line. Here's
d28ebecd 1078how it works: the first time E<lt>E<gt> is evaluated, the @ARGV array is
a0d0e21e
LW
1079checked, and if it is null, C<$ARGV[0]> is set to "-", which when opened
1080gives you standard input. The @ARGV array is then processed as a list
1081of filenames. The loop
1082
1083 while (<>) {
1084 ... # code for each line
1085 }
1086
1087is equivalent to the following Perl-like pseudo code:
1088
3e3baf6d 1089 unshift(@ARGV, '-') unless @ARGV;
a0d0e21e
LW
1090 while ($ARGV = shift) {
1091 open(ARGV, $ARGV);
1092 while (<ARGV>) {
1093 ... # code for each line
1094 }
1095 }
1096
1097except that it isn't so cumbersome to say, and will actually work. It
1098really does shift array @ARGV and put the current filename into variable
5f05dabc
PP
1099$ARGV. It also uses filehandle I<ARGV> internally--E<lt>E<gt> is just a
1100synonym for E<lt>ARGVE<gt>, which is magical. (The pseudo code above
1101doesn't work because it treats E<lt>ARGVE<gt> as non-magical.)
a0d0e21e 1102
d28ebecd 1103You can modify @ARGV before the first E<lt>E<gt> as long as the array ends up
a0d0e21e
LW
1104containing the list of filenames you really want. Line numbers (C<$.>)
1105continue as if the input were one big happy file. (But see example
1106under eof() for how to reset line numbers on each file.)
1107
1108If you want to set @ARGV to your own list of files, go right ahead. If
54310121 1109you want to pass switches into your script, you can use one of the
a0d0e21e
LW
1110Getopts modules or put a loop on the front like this:
1111
1112 while ($_ = $ARGV[0], /^-/) {
1113 shift;
1114 last if /^--$/;
1115 if (/^-D(.*)/) { $debug = $1 }
1116 if (/^-v/) { $verbose++ }
1117 ... # other switches
1118 }
1119 while (<>) {
1120 ... # code for each line
1121 }
1122
d28ebecd 1123The E<lt>E<gt> symbol will return FALSE only once. If you call it again after
a0d0e21e
LW
1124this it will assume you are processing another @ARGV list, and if you
1125haven't set @ARGV, will input from STDIN.
1126
1127If the string inside the angle brackets is a reference to a scalar
5f05dabc 1128variable (e.g., E<lt>$fooE<gt>), then that variable contains the name of the
cb1a09d0
AD
1129filehandle to input from, or a reference to the same. For example:
1130
1131 $fh = \*STDIN;
1132 $line = <$fh>;
a0d0e21e 1133
cb1a09d0
AD
1134If the string inside angle brackets is not a filehandle or a scalar
1135variable containing a filehandle name or reference, then it is interpreted
4633a7c4
LW
1136as a filename pattern to be globbed, and either a list of filenames or the
1137next filename in the list is returned, depending on context. One level of
1138$ interpretation is done first, but you can't say C<E<lt>$fooE<gt>>
1139because that's an indirect filehandle as explained in the previous
6ee5d4e7 1140paragraph. (In older versions of Perl, programmers would insert curly
4633a7c4 1141brackets to force interpretation as a filename glob: C<E<lt>${foo}E<gt>>.
d28ebecd 1142These days, it's considered cleaner to call the internal function directly
4633a7c4
LW
1143as C<glob($foo)>, which is probably the right way to have done it in the
1144first place.) Example:
a0d0e21e
LW
1145
1146 while (<*.c>) {
1147 chmod 0644, $_;
1148 }
1149
1150is equivalent to
1151
1152 open(FOO, "echo *.c | tr -s ' \t\r\f' '\\012\\012\\012\\012'|");
1153 while (<FOO>) {
1154 chop;
1155 chmod 0644, $_;
1156 }
1157
1158In fact, it's currently implemented that way. (Which means it will not
1159work on filenames with spaces in them unless you have csh(1) on your
1160machine.) Of course, the shortest way to do the above is:
1161
1162 chmod 0644, <*.c>;
1163
1164Because globbing invokes a shell, it's often faster to call readdir() yourself
5f05dabc 1165and do your own grep() on the filenames. Furthermore, due to its current
54310121 1166implementation of using a shell, the glob() routine may get "Arg list too
a0d0e21e
LW
1167long" errors (unless you've installed tcsh(1L) as F</bin/csh>).
1168
5f05dabc 1169A glob evaluates its (embedded) argument only when it is starting a new
4633a7c4
LW
1170list. All values must be read before it will start over. In a list
1171context this isn't important, because you automatically get them all
1172anyway. In a scalar context, however, the operator returns the next value
1173each time it is called, or a FALSE value if you've just run out. Again,
1174FALSE is returned only once. So if you're expecting a single value from
1175a glob, it is much better to say
1176
1177 ($file) = <blurch*>;
1178
1179than
1180
1181 $file = <blurch*>;
1182
1183because the latter will alternate between returning a filename and
54310121 1184returning FALSE.
4633a7c4
LW
1185
1186It you're trying to do variable interpolation, it's definitely better
1187to use the glob() function, because the older notation can cause people
e37d713d 1188to become confused with the indirect filehandle notation.
4633a7c4
LW
1189
1190 @files = glob("$dir/*.[ch]");
1191 @files = glob($files[$i]);
1192
a0d0e21e
LW
1193=head2 Constant Folding
1194
1195Like C, Perl does a certain amount of expression evaluation at
1196compile time, whenever it determines that all of the arguments to an
1197operator are static and have no side effects. In particular, string
1198concatenation happens at compile time between literals that don't do
1199variable substitution. Backslash interpretation also happens at
1200compile time. You can say
1201
1202 'Now is the time for all' . "\n" .
1203 'good men to come to.'
1204
54310121 1205and this all reduces to one string internally. Likewise, if
a0d0e21e
LW
1206you say
1207
1208 foreach $file (@filenames) {
1209 if (-s $file > 5 + 100 * 2**16) { ... }
54310121 1210 }
a0d0e21e 1211
54310121 1212the compiler will precompute the number that
a0d0e21e
LW
1213expression represents so that the interpreter
1214won't have to.
1215
1216
55497cff 1217=head2 Integer Arithmetic
a0d0e21e
LW
1218
1219By default Perl assumes that it must do most of its arithmetic in
1220floating point. But by saying
1221
1222 use integer;
1223
1224you may tell the compiler that it's okay to use integer operations
1225from here to the end of the enclosing BLOCK. An inner BLOCK may
54310121 1226countermand this by saying
a0d0e21e
LW
1227
1228 no integer;
1229
1230which lasts until the end of that BLOCK.
1231
55497cff
PP
1232The bitwise operators ("&", "|", "^", "~", "<<", and ">>") always
1233produce integral results. However, C<use integer> still has meaning
1234for them. By default, their results are interpreted as unsigned
1235integers. However, if C<use integer> is in effect, their results are
5f05dabc 1236interpreted as signed integers. For example, C<~0> usually evaluates
55497cff 1237to a large integral value. However, C<use integer; ~0> is -1.
68dc0745
PP
1238
1239=head2 Floating-point Arithmetic
1240
1241While C<use integer> provides integer-only arithmetic, there is no
1242similar ways to provide rounding or truncation at a certain number of
1243decimal places. For rounding to a certain number of digits, sprintf()
1244or printf() is usually the easiest route.
1245
1246The POSIX module (part of the standard perl distribution) implements
1247ceil(), floor(), and a number of other mathematical and trigonometric
1248functions. The Math::Complex module (part of the standard perl
1249distribution) defines a number of mathematical functions that can also
1250work on real numbers. Math::Complex not as efficient as POSIX, but
1251POSIX can't work with complex numbers.
1252
1253Rounding in financial applications can have serious implications, and
1254the rounding method used should be specified precisely. In these
1255cases, it probably pays not to trust whichever system rounding is
1256being used by Perl, but to instead implement the rounding function you
1257need yourself.