1 | =head1 NAME
|
---|
2 | X<operator>
|
---|
3 |
|
---|
4 | perlop - Perl operators and precedence
|
---|
5 |
|
---|
6 | =head1 DESCRIPTION
|
---|
7 |
|
---|
8 | =head2 Operator Precedence and Associativity
|
---|
9 | X<operator, precedence> X<precedence> X<associativity>
|
---|
10 |
|
---|
11 | Operator precedence and associativity work in Perl more or less like
|
---|
12 | they do in mathematics.
|
---|
13 |
|
---|
14 | I<Operator precedence> means some operators are evaluated before
|
---|
15 | others. For example, in C<2 + 4 * 5>, the multiplication has higher
|
---|
16 | precedence so C<4 * 5> is evaluated first yielding C<2 + 20 ==
|
---|
17 | 22> and not C<6 * 5 == 30>.
|
---|
18 |
|
---|
19 | I<Operator associativity> defines what happens if a sequence of the
|
---|
20 | same operators is used one after another: whether the evaluator will
|
---|
21 | evaluate the left operations first or the right. For example, in C<8
|
---|
22 | - 4 - 2>, subtraction is left associative so Perl evaluates the
|
---|
23 | expression left to right. C<8 - 4> is evaluated first making the
|
---|
24 | expression C<4 - 2 == 2> and not C<8 - 2 == 6>.
|
---|
25 |
|
---|
26 | Perl operators have the following associativity and precedence,
|
---|
27 | listed from highest precedence to lowest. Operators borrowed from
|
---|
28 | C keep the same precedence relationship with each other, even where
|
---|
29 | C's precedence is slightly screwy. (This makes learning Perl easier
|
---|
30 | for C folks.) With very few exceptions, these all operate on scalar
|
---|
31 | values only, not array values.
|
---|
32 |
|
---|
33 | left terms and list operators (leftward)
|
---|
34 | left ->
|
---|
35 | nonassoc ++ --
|
---|
36 | right **
|
---|
37 | right ! ~ \ and unary + and -
|
---|
38 | left =~ !~
|
---|
39 | left * / % x
|
---|
40 | left + - .
|
---|
41 | left << >>
|
---|
42 | nonassoc named unary operators
|
---|
43 | nonassoc < > <= >= lt gt le ge
|
---|
44 | nonassoc == != <=> eq ne cmp
|
---|
45 | left &
|
---|
46 | left | ^
|
---|
47 | left &&
|
---|
48 | left ||
|
---|
49 | nonassoc .. ...
|
---|
50 | right ?:
|
---|
51 | right = += -= *= etc.
|
---|
52 | left , =>
|
---|
53 | nonassoc list operators (rightward)
|
---|
54 | right not
|
---|
55 | left and
|
---|
56 | left or xor
|
---|
57 |
|
---|
58 | In the following sections, these operators are covered in precedence order.
|
---|
59 |
|
---|
60 | Many operators can be overloaded for objects. See L<overload>.
|
---|
61 |
|
---|
62 | =head2 Terms and List Operators (Leftward)
|
---|
63 | X<list operator> X<operator, list> X<term>
|
---|
64 |
|
---|
65 | A TERM has the highest precedence in Perl. They include variables,
|
---|
66 | quote and quote-like operators, any expression in parentheses,
|
---|
67 | and any function whose arguments are parenthesized. Actually, there
|
---|
68 | aren't really functions in this sense, just list operators and unary
|
---|
69 | operators behaving as functions because you put parentheses around
|
---|
70 | the arguments. These are all documented in L<perlfunc>.
|
---|
71 |
|
---|
72 | If any list operator (print(), etc.) or any unary operator (chdir(), etc.)
|
---|
73 | is followed by a left parenthesis as the next token, the operator and
|
---|
74 | arguments within parentheses are taken to be of highest precedence,
|
---|
75 | just like a normal function call.
|
---|
76 |
|
---|
77 | In the absence of parentheses, the precedence of list operators such as
|
---|
78 | C<print>, C<sort>, or C<chmod> is either very high or very low depending on
|
---|
79 | whether you are looking at the left side or the right side of the operator.
|
---|
80 | For example, in
|
---|
81 |
|
---|
82 | @ary = (1, 3, sort 4, 2);
|
---|
83 | print @ary; # prints 1324
|
---|
84 |
|
---|
85 | the commas on the right of the sort are evaluated before the sort,
|
---|
86 | but the commas on the left are evaluated after. In other words,
|
---|
87 | list operators tend to gobble up all arguments that follow, and
|
---|
88 | then act like a simple TERM with regard to the preceding expression.
|
---|
89 | Be careful with parentheses:
|
---|
90 |
|
---|
91 | # These evaluate exit before doing the print:
|
---|
92 | print($foo, exit); # Obviously not what you want.
|
---|
93 | print $foo, exit; # Nor is this.
|
---|
94 |
|
---|
95 | # These do the print before evaluating exit:
|
---|
96 | (print $foo), exit; # This is what you want.
|
---|
97 | print($foo), exit; # Or this.
|
---|
98 | print ($foo), exit; # Or even this.
|
---|
99 |
|
---|
100 | Also note that
|
---|
101 |
|
---|
102 | print ($foo & 255) + 1, "\n";
|
---|
103 |
|
---|
104 | probably doesn't do what you expect at first glance. The parentheses
|
---|
105 | enclose the argument list for C<print> which is evaluated (printing
|
---|
106 | the result of C<$foo & 255>). Then one is added to the return value
|
---|
107 | of C<print> (usually 1). The result is something like this:
|
---|
108 |
|
---|
109 | 1 + 1, "\n"; # Obviously not what you meant.
|
---|
110 |
|
---|
111 | To do what you meant properly, you must write:
|
---|
112 |
|
---|
113 | print(($foo & 255) + 1, "\n");
|
---|
114 |
|
---|
115 | See L<Named Unary Operators> for more discussion of this.
|
---|
116 |
|
---|
117 | Also parsed as terms are the C<do {}> and C<eval {}> constructs, as
|
---|
118 | well as subroutine and method calls, and the anonymous
|
---|
119 | constructors C<[]> and C<{}>.
|
---|
120 |
|
---|
121 | See also L<Quote and Quote-like Operators> toward the end of this section,
|
---|
122 | as well as L<"I/O Operators">.
|
---|
123 |
|
---|
124 | =head2 The Arrow Operator
|
---|
125 | X<arrow> X<dereference> X<< -> >>
|
---|
126 |
|
---|
127 | "C<< -> >>" is an infix dereference operator, just as it is in C
|
---|
128 | and C++. If the right side is either a C<[...]>, C<{...}>, or a
|
---|
129 | C<(...)> subscript, then the left side must be either a hard or
|
---|
130 | symbolic reference to an array, a hash, or a subroutine respectively.
|
---|
131 | (Or technically speaking, a location capable of holding a hard
|
---|
132 | reference, if it's an array or hash reference being used for
|
---|
133 | assignment.) See L<perlreftut> and L<perlref>.
|
---|
134 |
|
---|
135 | Otherwise, the right side is a method name or a simple scalar
|
---|
136 | variable containing either the method name or a subroutine reference,
|
---|
137 | and the left side must be either an object (a blessed reference)
|
---|
138 | or a class name (that is, a package name). See L<perlobj>.
|
---|
139 |
|
---|
140 | =head2 Auto-increment and Auto-decrement
|
---|
141 | X<increment> X<auto-increment> X<++> X<decrement> X<auto-decrement> X<-->
|
---|
142 |
|
---|
143 | "++" and "--" work as in C. That is, if placed before a variable,
|
---|
144 | they increment or decrement the variable by one before returning the
|
---|
145 | value, and if placed after, increment or decrement after returning the
|
---|
146 | value.
|
---|
147 |
|
---|
148 | $i = 0; $j = 0;
|
---|
149 | print $i++; # prints 0
|
---|
150 | print ++$j; # prints 1
|
---|
151 |
|
---|
152 | Note that just as in C, Perl doesn't define B<when> the variable is
|
---|
153 | incremented or decremented. You just know it will be done sometime
|
---|
154 | before or after the value is returned. This also means that modifying
|
---|
155 | a variable twice in the same statement will lead to undefined behaviour.
|
---|
156 | Avoid statements like:
|
---|
157 |
|
---|
158 | $i = $i ++;
|
---|
159 | print ++ $i + $i ++;
|
---|
160 |
|
---|
161 | Perl will not guarantee what the result of the above statements is.
|
---|
162 |
|
---|
163 | The auto-increment operator has a little extra builtin magic to it. If
|
---|
164 | you increment a variable that is numeric, or that has ever been used in
|
---|
165 | a numeric context, you get a normal increment. If, however, the
|
---|
166 | variable has been used in only string contexts since it was set, and
|
---|
167 | has a value that is not the empty string and matches the pattern
|
---|
168 | C</^[a-zA-Z]*[0-9]*\z/>, the increment is done as a string, preserving each
|
---|
169 | character within its range, with carry:
|
---|
170 |
|
---|
171 | print ++($foo = '99'); # prints '100'
|
---|
172 | print ++($foo = 'a0'); # prints 'a1'
|
---|
173 | print ++($foo = 'Az'); # prints 'Ba'
|
---|
174 | print ++($foo = 'zz'); # prints 'aaa'
|
---|
175 |
|
---|
176 | C<undef> is always treated as numeric, and in particular is changed
|
---|
177 | to C<0> before incrementing (so that a post-increment of an undef value
|
---|
178 | will return C<0> rather than C<undef>).
|
---|
179 |
|
---|
180 | The auto-decrement operator is not magical.
|
---|
181 |
|
---|
182 | =head2 Exponentiation
|
---|
183 | X<**> X<exponentiation> X<power>
|
---|
184 |
|
---|
185 | Binary "**" is the exponentiation operator. It binds even more
|
---|
186 | tightly than unary minus, so -2**4 is -(2**4), not (-2)**4. (This is
|
---|
187 | implemented using C's pow(3) function, which actually works on doubles
|
---|
188 | internally.)
|
---|
189 |
|
---|
190 | =head2 Symbolic Unary Operators
|
---|
191 | X<unary operator> X<operator, unary>
|
---|
192 |
|
---|
193 | Unary "!" performs logical negation, i.e., "not". See also C<not> for a lower
|
---|
194 | precedence version of this.
|
---|
195 | X<!>
|
---|
196 |
|
---|
197 | Unary "-" performs arithmetic negation if the operand is numeric. If
|
---|
198 | the operand is an identifier, a string consisting of a minus sign
|
---|
199 | concatenated with the identifier is returned. Otherwise, if the string
|
---|
200 | starts with a plus or minus, a string starting with the opposite sign
|
---|
201 | is returned. One effect of these rules is that -bareword is equivalent
|
---|
202 | to the string "-bareword". If, however, the string begins with a
|
---|
203 | non-alphabetic character (exluding "+" or "-"), Perl will attempt to convert
|
---|
204 | the string to a numeric and the arithmetic negation is performed. If the
|
---|
205 | string cannot be cleanly converted to a numeric, Perl will give the warning
|
---|
206 | B<Argument "the string" isn't numeric in negation (-) at ...>.
|
---|
207 | X<-> X<negation, arithmetic>
|
---|
208 |
|
---|
209 | Unary "~" performs bitwise negation, i.e., 1's complement. For
|
---|
210 | example, C<0666 & ~027> is 0640. (See also L<Integer Arithmetic> and
|
---|
211 | L<Bitwise String Operators>.) Note that the width of the result is
|
---|
212 | platform-dependent: ~0 is 32 bits wide on a 32-bit platform, but 64
|
---|
213 | bits wide on a 64-bit platform, so if you are expecting a certain bit
|
---|
214 | width, remember to use the & operator to mask off the excess bits.
|
---|
215 | X<~> X<negation, binary>
|
---|
216 |
|
---|
217 | Unary "+" has no effect whatsoever, even on strings. It is useful
|
---|
218 | syntactically for separating a function name from a parenthesized expression
|
---|
219 | that would otherwise be interpreted as the complete list of function
|
---|
220 | arguments. (See examples above under L<Terms and List Operators (Leftward)>.)
|
---|
221 | X<+>
|
---|
222 |
|
---|
223 | Unary "\" creates a reference to whatever follows it. See L<perlreftut>
|
---|
224 | and L<perlref>. Do not confuse this behavior with the behavior of
|
---|
225 | backslash within a string, although both forms do convey the notion
|
---|
226 | of protecting the next thing from interpolation.
|
---|
227 | X<\> X<reference> X<backslash>
|
---|
228 |
|
---|
229 | =head2 Binding Operators
|
---|
230 | X<binding> X<operator, binding> X<=~> X<!~>
|
---|
231 |
|
---|
232 | Binary "=~" binds a scalar expression to a pattern match. Certain operations
|
---|
233 | search or modify the string $_ by default. This operator makes that kind
|
---|
234 | of operation work on some other string. The right argument is a search
|
---|
235 | pattern, substitution, or transliteration. The left argument is what is
|
---|
236 | supposed to be searched, substituted, or transliterated instead of the default
|
---|
237 | $_. When used in scalar context, the return value generally indicates the
|
---|
238 | success of the operation. Behavior in list context depends on the particular
|
---|
239 | operator. See L</"Regexp Quote-Like Operators"> for details and
|
---|
240 | L<perlretut> for examples using these operators.
|
---|
241 |
|
---|
242 | If the right argument is an expression rather than a search pattern,
|
---|
243 | substitution, or transliteration, it is interpreted as a search pattern at run
|
---|
244 | time.
|
---|
245 |
|
---|
246 | Binary "!~" is just like "=~" except the return value is negated in
|
---|
247 | the logical sense.
|
---|
248 |
|
---|
249 | =head2 Multiplicative Operators
|
---|
250 | X<operator, multiplicative>
|
---|
251 |
|
---|
252 | Binary "*" multiplies two numbers.
|
---|
253 | X<*>
|
---|
254 |
|
---|
255 | Binary "/" divides two numbers.
|
---|
256 | X</> X<slash>
|
---|
257 |
|
---|
258 | Binary "%" computes the modulus of two numbers. Given integer
|
---|
259 | operands C<$a> and C<$b>: If C<$b> is positive, then C<$a % $b> is
|
---|
260 | C<$a> minus the largest multiple of C<$b> that is not greater than
|
---|
261 | C<$a>. If C<$b> is negative, then C<$a % $b> is C<$a> minus the
|
---|
262 | smallest multiple of C<$b> that is not less than C<$a> (i.e. the
|
---|
263 | result will be less than or equal to zero).
|
---|
264 | Note that when C<use integer> is in scope, "%" gives you direct access
|
---|
265 | to the modulus operator as implemented by your C compiler. This
|
---|
266 | operator is not as well defined for negative operands, but it will
|
---|
267 | execute faster.
|
---|
268 | X<%> X<remainder> X<modulus> X<mod>
|
---|
269 |
|
---|
270 | Binary "x" is the repetition operator. In scalar context or if the left
|
---|
271 | operand is not enclosed in parentheses, it returns a string consisting
|
---|
272 | of the left operand repeated the number of times specified by the right
|
---|
273 | operand. In list context, if the left operand is enclosed in
|
---|
274 | parentheses or is a list formed by C<qw/STRING/>, it repeats the list.
|
---|
275 | If the right operand is zero or negative, it returns an empty string
|
---|
276 | or an empty list, depending on the context.
|
---|
277 | X<x>
|
---|
278 |
|
---|
279 | print '-' x 80; # print row of dashes
|
---|
280 |
|
---|
281 | print "\t" x ($tab/8), ' ' x ($tab%8); # tab over
|
---|
282 |
|
---|
283 | @ones = (1) x 80; # a list of 80 1's
|
---|
284 | @ones = (5) x @ones; # set all elements to 5
|
---|
285 |
|
---|
286 |
|
---|
287 | =head2 Additive Operators
|
---|
288 | X<operator, additive>
|
---|
289 |
|
---|
290 | Binary "+" returns the sum of two numbers.
|
---|
291 | X<+>
|
---|
292 |
|
---|
293 | Binary "-" returns the difference of two numbers.
|
---|
294 | X<->
|
---|
295 |
|
---|
296 | Binary "." concatenates two strings.
|
---|
297 | X<string, concatenation> X<concatenation>
|
---|
298 | X<cat> X<concat> X<concatenate> X<.>
|
---|
299 |
|
---|
300 | =head2 Shift Operators
|
---|
301 | X<shift operator> X<operator, shift> X<<< << >>>
|
---|
302 | X<<< >> >>> X<right shift> X<left shift> X<bitwise shift>
|
---|
303 | X<shl> X<shr> X<shift, right> X<shift, left>
|
---|
304 |
|
---|
305 | Binary "<<" returns the value of its left argument shifted left by the
|
---|
306 | number of bits specified by the right argument. Arguments should be
|
---|
307 | integers. (See also L<Integer Arithmetic>.)
|
---|
308 |
|
---|
309 | Binary ">>" returns the value of its left argument shifted right by
|
---|
310 | the number of bits specified by the right argument. Arguments should
|
---|
311 | be integers. (See also L<Integer Arithmetic>.)
|
---|
312 |
|
---|
313 | Note that both "<<" and ">>" in Perl are implemented directly using
|
---|
314 | "<<" and ">>" in C. If C<use integer> (see L<Integer Arithmetic>) is
|
---|
315 | in force then signed C integers are used, else unsigned C integers are
|
---|
316 | used. Either way, the implementation isn't going to generate results
|
---|
317 | larger than the size of the integer type Perl was built with (32 bits
|
---|
318 | or 64 bits).
|
---|
319 |
|
---|
320 | The result of overflowing the range of the integers is undefined
|
---|
321 | because it is undefined also in C. In other words, using 32-bit
|
---|
322 | integers, C<< 1 << 32 >> is undefined. Shifting by a negative number
|
---|
323 | of bits is also undefined.
|
---|
324 |
|
---|
325 | =head2 Named Unary Operators
|
---|
326 | X<operator, named unary>
|
---|
327 |
|
---|
328 | The various named unary operators are treated as functions with one
|
---|
329 | argument, with optional parentheses.
|
---|
330 |
|
---|
331 | If any list operator (print(), etc.) or any unary operator (chdir(), etc.)
|
---|
332 | is followed by a left parenthesis as the next token, the operator and
|
---|
333 | arguments within parentheses are taken to be of highest precedence,
|
---|
334 | just like a normal function call. For example,
|
---|
335 | because named unary operators are higher precedence than ||:
|
---|
336 |
|
---|
337 | chdir $foo || die; # (chdir $foo) || die
|
---|
338 | chdir($foo) || die; # (chdir $foo) || die
|
---|
339 | chdir ($foo) || die; # (chdir $foo) || die
|
---|
340 | chdir +($foo) || die; # (chdir $foo) || die
|
---|
341 |
|
---|
342 | but, because * is higher precedence than named operators:
|
---|
343 |
|
---|
344 | chdir $foo * 20; # chdir ($foo * 20)
|
---|
345 | chdir($foo) * 20; # (chdir $foo) * 20
|
---|
346 | chdir ($foo) * 20; # (chdir $foo) * 20
|
---|
347 | chdir +($foo) * 20; # chdir ($foo * 20)
|
---|
348 |
|
---|
349 | rand 10 * 20; # rand (10 * 20)
|
---|
350 | rand(10) * 20; # (rand 10) * 20
|
---|
351 | rand (10) * 20; # (rand 10) * 20
|
---|
352 | rand +(10) * 20; # rand (10 * 20)
|
---|
353 |
|
---|
354 | Regarding precedence, the filetest operators, like C<-f>, C<-M>, etc. are
|
---|
355 | treated like named unary operators, but they don't follow this functional
|
---|
356 | parenthesis rule. That means, for example, that C<-f($file).".bak"> is
|
---|
357 | equivalent to C<-f "$file.bak">.
|
---|
358 | X<-X> X<filetest> X<operator, filetest>
|
---|
359 |
|
---|
360 | See also L<"Terms and List Operators (Leftward)">.
|
---|
361 |
|
---|
362 | =head2 Relational Operators
|
---|
363 | X<relational operator> X<operator, relational>
|
---|
364 |
|
---|
365 | Binary "<" returns true if the left argument is numerically less than
|
---|
366 | the right argument.
|
---|
367 | X<< < >>
|
---|
368 |
|
---|
369 | Binary ">" returns true if the left argument is numerically greater
|
---|
370 | than the right argument.
|
---|
371 | X<< > >>
|
---|
372 |
|
---|
373 | Binary "<=" returns true if the left argument is numerically less than
|
---|
374 | or equal to the right argument.
|
---|
375 | X<< <= >>
|
---|
376 |
|
---|
377 | Binary ">=" returns true if the left argument is numerically greater
|
---|
378 | than or equal to the right argument.
|
---|
379 | X<< >= >>
|
---|
380 |
|
---|
381 | Binary "lt" returns true if the left argument is stringwise less than
|
---|
382 | the right argument.
|
---|
383 | X<< lt >>
|
---|
384 |
|
---|
385 | Binary "gt" returns true if the left argument is stringwise greater
|
---|
386 | than the right argument.
|
---|
387 | X<< gt >>
|
---|
388 |
|
---|
389 | Binary "le" returns true if the left argument is stringwise less than
|
---|
390 | or equal to the right argument.
|
---|
391 | X<< le >>
|
---|
392 |
|
---|
393 | Binary "ge" returns true if the left argument is stringwise greater
|
---|
394 | than or equal to the right argument.
|
---|
395 | X<< ge >>
|
---|
396 |
|
---|
397 | =head2 Equality Operators
|
---|
398 | X<equality> X<equal> X<equals> X<operator, equality>
|
---|
399 |
|
---|
400 | Binary "==" returns true if the left argument is numerically equal to
|
---|
401 | the right argument.
|
---|
402 | X<==>
|
---|
403 |
|
---|
404 | Binary "!=" returns true if the left argument is numerically not equal
|
---|
405 | to the right argument.
|
---|
406 | X<!=>
|
---|
407 |
|
---|
408 | Binary "<=>" returns -1, 0, or 1 depending on whether the left
|
---|
409 | argument is numerically less than, equal to, or greater than the right
|
---|
410 | argument. If your platform supports NaNs (not-a-numbers) as numeric
|
---|
411 | values, using them with "<=>" returns undef. NaN is not "<", "==", ">",
|
---|
412 | "<=" or ">=" anything (even NaN), so those 5 return false. NaN != NaN
|
---|
413 | returns true, as does NaN != anything else. If your platform doesn't
|
---|
414 | support NaNs then NaN is just a string with numeric value 0.
|
---|
415 | X<< <=> >> X<spaceship>
|
---|
416 |
|
---|
417 | perl -le '$a = "NaN"; print "No NaN support here" if $a == $a'
|
---|
418 | perl -le '$a = "NaN"; print "NaN support here" if $a != $a'
|
---|
419 |
|
---|
420 | Binary "eq" returns true if the left argument is stringwise equal to
|
---|
421 | the right argument.
|
---|
422 | X<eq>
|
---|
423 |
|
---|
424 | Binary "ne" returns true if the left argument is stringwise not equal
|
---|
425 | to the right argument.
|
---|
426 | X<ne>
|
---|
427 |
|
---|
428 | Binary "cmp" returns -1, 0, or 1 depending on whether the left
|
---|
429 | argument is stringwise less than, equal to, or greater than the right
|
---|
430 | argument.
|
---|
431 | X<cmp>
|
---|
432 |
|
---|
433 | "lt", "le", "ge", "gt" and "cmp" use the collation (sort) order specified
|
---|
434 | by the current locale if C<use locale> is in effect. See L<perllocale>.
|
---|
435 |
|
---|
436 | =head2 Bitwise And
|
---|
437 | X<operator, bitwise, and> X<bitwise and> X<&>
|
---|
438 |
|
---|
439 | Binary "&" returns its operands ANDed together bit by bit.
|
---|
440 | (See also L<Integer Arithmetic> and L<Bitwise String Operators>.)
|
---|
441 |
|
---|
442 | Note that "&" has lower priority than relational operators, so for example
|
---|
443 | the brackets are essential in a test like
|
---|
444 |
|
---|
445 | print "Even\n" if ($x & 1) == 0;
|
---|
446 |
|
---|
447 | =head2 Bitwise Or and Exclusive Or
|
---|
448 | X<operator, bitwise, or> X<bitwise or> X<|> X<operator, bitwise, xor>
|
---|
449 | X<bitwise xor> X<^>
|
---|
450 |
|
---|
451 | Binary "|" returns its operands ORed together bit by bit.
|
---|
452 | (See also L<Integer Arithmetic> and L<Bitwise String Operators>.)
|
---|
453 |
|
---|
454 | Binary "^" returns its operands XORed together bit by bit.
|
---|
455 | (See also L<Integer Arithmetic> and L<Bitwise String Operators>.)
|
---|
456 |
|
---|
457 | Note that "|" and "^" have lower priority than relational operators, so
|
---|
458 | for example the brackets are essential in a test like
|
---|
459 |
|
---|
460 | print "false\n" if (8 | 2) != 10;
|
---|
461 |
|
---|
462 | =head2 C-style Logical And
|
---|
463 | X<&&> X<logical and> X<operator, logical, and>
|
---|
464 |
|
---|
465 | Binary "&&" performs a short-circuit logical AND operation. That is,
|
---|
466 | if the left operand is false, the right operand is not even evaluated.
|
---|
467 | Scalar or list context propagates down to the right operand if it
|
---|
468 | is evaluated.
|
---|
469 |
|
---|
470 | =head2 C-style Logical Or
|
---|
471 | X<||> X<operator, logical, or>
|
---|
472 |
|
---|
473 | Binary "||" performs a short-circuit logical OR operation. That is,
|
---|
474 | if the left operand is true, the right operand is not even evaluated.
|
---|
475 | Scalar or list context propagates down to the right operand if it
|
---|
476 | is evaluated.
|
---|
477 |
|
---|
478 | The C<||> and C<&&> operators return the last value evaluated
|
---|
479 | (unlike C's C<||> and C<&&>, which return 0 or 1). Thus, a reasonably
|
---|
480 | portable way to find out the home directory might be:
|
---|
481 |
|
---|
482 | $home = $ENV{'HOME'} || $ENV{'LOGDIR'} ||
|
---|
483 | (getpwuid($<))[7] || die "You're homeless!\n";
|
---|
484 |
|
---|
485 | In particular, this means that you shouldn't use this
|
---|
486 | for selecting between two aggregates for assignment:
|
---|
487 |
|
---|
488 | @a = @b || @c; # this is wrong
|
---|
489 | @a = scalar(@b) || @c; # really meant this
|
---|
490 | @a = @b ? @b : @c; # this works fine, though
|
---|
491 |
|
---|
492 | As more readable alternatives to C<&&> and C<||> when used for
|
---|
493 | control flow, Perl provides C<and> and C<or> operators (see below).
|
---|
494 | The short-circuit behavior is identical. The precedence of "and" and
|
---|
495 | "or" is much lower, however, so that you can safely use them after a
|
---|
496 | list operator without the need for parentheses:
|
---|
497 |
|
---|
498 | unlink "alpha", "beta", "gamma"
|
---|
499 | or gripe(), next LINE;
|
---|
500 |
|
---|
501 | With the C-style operators that would have been written like this:
|
---|
502 |
|
---|
503 | unlink("alpha", "beta", "gamma")
|
---|
504 | || (gripe(), next LINE);
|
---|
505 |
|
---|
506 | Using "or" for assignment is unlikely to do what you want; see below.
|
---|
507 |
|
---|
508 | =head2 Range Operators
|
---|
509 | X<operator, range> X<range> X<..> X<...>
|
---|
510 |
|
---|
511 | Binary ".." is the range operator, which is really two different
|
---|
512 | operators depending on the context. In list context, it returns a
|
---|
513 | list of values counting (up by ones) from the left value to the right
|
---|
514 | value. If the left value is greater than the right value then it
|
---|
515 | returns the empty list. The range operator is useful for writing
|
---|
516 | C<foreach (1..10)> loops and for doing slice operations on arrays. In
|
---|
517 | the current implementation, no temporary array is created when the
|
---|
518 | range operator is used as the expression in C<foreach> loops, but older
|
---|
519 | versions of Perl might burn a lot of memory when you write something
|
---|
520 | like this:
|
---|
521 |
|
---|
522 | for (1 .. 1_000_000) {
|
---|
523 | # code
|
---|
524 | }
|
---|
525 |
|
---|
526 | The range operator also works on strings, using the magical auto-increment,
|
---|
527 | see below.
|
---|
528 |
|
---|
529 | In scalar context, ".." returns a boolean value. The operator is
|
---|
530 | bistable, like a flip-flop, and emulates the line-range (comma) operator
|
---|
531 | of B<sed>, B<awk>, and various editors. Each ".." operator maintains its
|
---|
532 | own boolean state. It is false as long as its left operand is false.
|
---|
533 | Once the left operand is true, the range operator stays true until the
|
---|
534 | right operand is true, I<AFTER> which the range operator becomes false
|
---|
535 | again. It doesn't become false till the next time the range operator is
|
---|
536 | evaluated. It can test the right operand and become false on the same
|
---|
537 | evaluation it became true (as in B<awk>), but it still returns true once.
|
---|
538 | If you don't want it to test the right operand till the next
|
---|
539 | evaluation, as in B<sed>, just use three dots ("...") instead of
|
---|
540 | two. In all other regards, "..." behaves just like ".." does.
|
---|
541 |
|
---|
542 | The right operand is not evaluated while the operator is in the
|
---|
543 | "false" state, and the left operand is not evaluated while the
|
---|
544 | operator is in the "true" state. The precedence is a little lower
|
---|
545 | than || and &&. The value returned is either the empty string for
|
---|
546 | false, or a sequence number (beginning with 1) for true. The
|
---|
547 | sequence number is reset for each range encountered. The final
|
---|
548 | sequence number in a range has the string "E0" appended to it, which
|
---|
549 | doesn't affect its numeric value, but gives you something to search
|
---|
550 | for if you want to exclude the endpoint. You can exclude the
|
---|
551 | beginning point by waiting for the sequence number to be greater
|
---|
552 | than 1.
|
---|
553 |
|
---|
554 | If either operand of scalar ".." is a constant expression,
|
---|
555 | that operand is considered true if it is equal (C<==>) to the current
|
---|
556 | input line number (the C<$.> variable).
|
---|
557 |
|
---|
558 | To be pedantic, the comparison is actually C<int(EXPR) == int(EXPR)>,
|
---|
559 | but that is only an issue if you use a floating point expression; when
|
---|
560 | implicitly using C<$.> as described in the previous paragraph, the
|
---|
561 | comparison is C<int(EXPR) == int($.)> which is only an issue when C<$.>
|
---|
562 | is set to a floating point value and you are not reading from a file.
|
---|
563 | Furthermore, C<"span" .. "spat"> or C<2.18 .. 3.14> will not do what
|
---|
564 | you want in scalar context because each of the operands are evaluated
|
---|
565 | using their integer representation.
|
---|
566 |
|
---|
567 | Examples:
|
---|
568 |
|
---|
569 | As a scalar operator:
|
---|
570 |
|
---|
571 | if (101 .. 200) { print; } # print 2nd hundred lines, short for
|
---|
572 | # if ($. == 101 .. $. == 200) ...
|
---|
573 |
|
---|
574 | next LINE if (1 .. /^$/); # skip header lines, short for
|
---|
575 | # ... if ($. == 1 .. /^$/);
|
---|
576 | # (typically in a loop labeled LINE)
|
---|
577 |
|
---|
578 | s/^/> / if (/^$/ .. eof()); # quote body
|
---|
579 |
|
---|
580 | # parse mail messages
|
---|
581 | while (<>) {
|
---|
582 | $in_header = 1 .. /^$/;
|
---|
583 | $in_body = /^$/ .. eof;
|
---|
584 | if ($in_header) {
|
---|
585 | # ...
|
---|
586 | } else { # in body
|
---|
587 | # ...
|
---|
588 | }
|
---|
589 | } continue {
|
---|
590 | close ARGV if eof; # reset $. each file
|
---|
591 | }
|
---|
592 |
|
---|
593 | Here's a simple example to illustrate the difference between
|
---|
594 | the two range operators:
|
---|
595 |
|
---|
596 | @lines = (" - Foo",
|
---|
597 | "01 - Bar",
|
---|
598 | "1 - Baz",
|
---|
599 | " - Quux");
|
---|
600 |
|
---|
601 | foreach (@lines) {
|
---|
602 | if (/0/ .. /1/) {
|
---|
603 | print "$_\n";
|
---|
604 | }
|
---|
605 | }
|
---|
606 |
|
---|
607 | This program will print only the line containing "Bar". If
|
---|
608 | the range operator is changed to C<...>, it will also print the
|
---|
609 | "Baz" line.
|
---|
610 |
|
---|
611 | And now some examples as a list operator:
|
---|
612 |
|
---|
613 | for (101 .. 200) { print; } # print $_ 100 times
|
---|
614 | @foo = @foo[0 .. $#foo]; # an expensive no-op
|
---|
615 | @foo = @foo[$#foo-4 .. $#foo]; # slice last 5 items
|
---|
616 |
|
---|
617 | The range operator (in list context) makes use of the magical
|
---|
618 | auto-increment algorithm if the operands are strings. You
|
---|
619 | can say
|
---|
620 |
|
---|
621 | @alphabet = ('A' .. 'Z');
|
---|
622 |
|
---|
623 | to get all normal letters of the English alphabet, or
|
---|
624 |
|
---|
625 | $hexdigit = (0 .. 9, 'a' .. 'f')[$num & 15];
|
---|
626 |
|
---|
627 | to get a hexadecimal digit, or
|
---|
628 |
|
---|
629 | @z2 = ('01' .. '31'); print $z2[$mday];
|
---|
630 |
|
---|
631 | to get dates with leading zeros. If the final value specified is not
|
---|
632 | in the sequence that the magical increment would produce, the sequence
|
---|
633 | goes until the next value would be longer than the final value
|
---|
634 | specified.
|
---|
635 |
|
---|
636 | Because each operand is evaluated in integer form, C<2.18 .. 3.14> will
|
---|
637 | return two elements in list context.
|
---|
638 |
|
---|
639 | @list = (2.18 .. 3.14); # same as @list = (2 .. 3);
|
---|
640 |
|
---|
641 | =head2 Conditional Operator
|
---|
642 | X<operator, conditional> X<operator, ternary> X<ternary> X<?:>
|
---|
643 |
|
---|
644 | Ternary "?:" is the conditional operator, just as in C. It works much
|
---|
645 | like an if-then-else. If the argument before the ? is true, the
|
---|
646 | argument before the : is returned, otherwise the argument after the :
|
---|
647 | is returned. For example:
|
---|
648 |
|
---|
649 | printf "I have %d dog%s.\n", $n,
|
---|
650 | ($n == 1) ? '' : "s";
|
---|
651 |
|
---|
652 | Scalar or list context propagates downward into the 2nd
|
---|
653 | or 3rd argument, whichever is selected.
|
---|
654 |
|
---|
655 | $a = $ok ? $b : $c; # get a scalar
|
---|
656 | @a = $ok ? @b : @c; # get an array
|
---|
657 | $a = $ok ? @b : @c; # oops, that's just a count!
|
---|
658 |
|
---|
659 | The operator may be assigned to if both the 2nd and 3rd arguments are
|
---|
660 | legal lvalues (meaning that you can assign to them):
|
---|
661 |
|
---|
662 | ($a_or_b ? $a : $b) = $c;
|
---|
663 |
|
---|
664 | Because this operator produces an assignable result, using assignments
|
---|
665 | without parentheses will get you in trouble. For example, this:
|
---|
666 |
|
---|
667 | $a % 2 ? $a += 10 : $a += 2
|
---|
668 |
|
---|
669 | Really means this:
|
---|
670 |
|
---|
671 | (($a % 2) ? ($a += 10) : $a) += 2
|
---|
672 |
|
---|
673 | Rather than this:
|
---|
674 |
|
---|
675 | ($a % 2) ? ($a += 10) : ($a += 2)
|
---|
676 |
|
---|
677 | That should probably be written more simply as:
|
---|
678 |
|
---|
679 | $a += ($a % 2) ? 10 : 2;
|
---|
680 |
|
---|
681 | =head2 Assignment Operators
|
---|
682 | X<assignment> X<operator, assignment> X<=> X<**=> X<+=> X<*=> X<&=>
|
---|
683 | X<<< <<= >>> X<&&=> X<-=> X</=> X<|=> X<<< >>= >>> X<||=> X<.=>
|
---|
684 | X<%=> X<^=> X<x=>
|
---|
685 |
|
---|
686 | "=" is the ordinary assignment operator.
|
---|
687 |
|
---|
688 | Assignment operators work as in C. That is,
|
---|
689 |
|
---|
690 | $a += 2;
|
---|
691 |
|
---|
692 | is equivalent to
|
---|
693 |
|
---|
694 | $a = $a + 2;
|
---|
695 |
|
---|
696 | although without duplicating any side effects that dereferencing the lvalue
|
---|
697 | might trigger, such as from tie(). Other assignment operators work similarly.
|
---|
698 | The following are recognized:
|
---|
699 |
|
---|
700 | **= += *= &= <<= &&=
|
---|
701 | -= /= |= >>= ||=
|
---|
702 | .= %= ^=
|
---|
703 | x=
|
---|
704 |
|
---|
705 | Although these are grouped by family, they all have the precedence
|
---|
706 | of assignment.
|
---|
707 |
|
---|
708 | Unlike in C, the scalar assignment operator produces a valid lvalue.
|
---|
709 | Modifying an assignment is equivalent to doing the assignment and
|
---|
710 | then modifying the variable that was assigned to. This is useful
|
---|
711 | for modifying a copy of something, like this:
|
---|
712 |
|
---|
713 | ($tmp = $global) =~ tr [A-Z] [a-z];
|
---|
714 |
|
---|
715 | Likewise,
|
---|
716 |
|
---|
717 | ($a += 2) *= 3;
|
---|
718 |
|
---|
719 | is equivalent to
|
---|
720 |
|
---|
721 | $a += 2;
|
---|
722 | $a *= 3;
|
---|
723 |
|
---|
724 | Similarly, a list assignment in list context produces the list of
|
---|
725 | lvalues assigned to, and a list assignment in scalar context returns
|
---|
726 | the number of elements produced by the expression on the right hand
|
---|
727 | side of the assignment.
|
---|
728 |
|
---|
729 | =head2 Comma Operator
|
---|
730 | X<comma> X<operator, comma> X<,>
|
---|
731 |
|
---|
732 | Binary "," is the comma operator. In scalar context it evaluates
|
---|
733 | its left argument, throws that value away, then evaluates its right
|
---|
734 | argument and returns that value. This is just like C's comma operator.
|
---|
735 |
|
---|
736 | In list context, it's just the list argument separator, and inserts
|
---|
737 | both its arguments into the list.
|
---|
738 |
|
---|
739 | The C<< => >> operator is a synonym for the comma, but forces any word
|
---|
740 | (consisting entirely of word characters) to its left to be interpreted
|
---|
741 | as a string (as of 5.001). This includes words that might otherwise be
|
---|
742 | considered a constant or function call.
|
---|
743 |
|
---|
744 | use constant FOO => "something";
|
---|
745 |
|
---|
746 | my %h = ( FOO => 23 );
|
---|
747 |
|
---|
748 | is equivalent to:
|
---|
749 |
|
---|
750 | my %h = ("FOO", 23);
|
---|
751 |
|
---|
752 | It is I<NOT>:
|
---|
753 |
|
---|
754 | my %h = ("something", 23);
|
---|
755 |
|
---|
756 | If the argument on the left is not a word, it is first interpreted as
|
---|
757 | an expression, and then the string value of that is used.
|
---|
758 |
|
---|
759 | The C<< => >> operator is helpful in documenting the correspondence
|
---|
760 | between keys and values in hashes, and other paired elements in lists.
|
---|
761 |
|
---|
762 | %hash = ( $key => $value );
|
---|
763 | login( $username => $password );
|
---|
764 |
|
---|
765 | =head2 List Operators (Rightward)
|
---|
766 | X<operator, list, rightward> X<list operator>
|
---|
767 |
|
---|
768 | On the right side of a list operator, it has very low precedence,
|
---|
769 | such that it controls all comma-separated expressions found there.
|
---|
770 | The only operators with lower precedence are the logical operators
|
---|
771 | "and", "or", and "not", which may be used to evaluate calls to list
|
---|
772 | operators without the need for extra parentheses:
|
---|
773 |
|
---|
774 | open HANDLE, "filename"
|
---|
775 | or die "Can't open: $!\n";
|
---|
776 |
|
---|
777 | See also discussion of list operators in L<Terms and List Operators (Leftward)>.
|
---|
778 |
|
---|
779 | =head2 Logical Not
|
---|
780 | X<operator, logical, not> X<not>
|
---|
781 |
|
---|
782 | Unary "not" returns the logical negation of the expression to its right.
|
---|
783 | It's the equivalent of "!" except for the very low precedence.
|
---|
784 |
|
---|
785 | =head2 Logical And
|
---|
786 | X<operator, logical, and> X<and>
|
---|
787 |
|
---|
788 | Binary "and" returns the logical conjunction of the two surrounding
|
---|
789 | expressions. It's equivalent to && except for the very low
|
---|
790 | precedence. This means that it short-circuits: i.e., the right
|
---|
791 | expression is evaluated only if the left expression is true.
|
---|
792 |
|
---|
793 | =head2 Logical or and Exclusive Or
|
---|
794 | X<operator, logical, or> X<operator, logical, xor> X<operator, logical, err>
|
---|
795 | X<operator, logical, defined or> X<operator, logical, exclusive or>
|
---|
796 | X<or> X<xor> X<err>
|
---|
797 |
|
---|
798 | Binary "or" returns the logical disjunction of the two surrounding
|
---|
799 | expressions. It's equivalent to || except for the very low precedence.
|
---|
800 | This makes it useful for control flow
|
---|
801 |
|
---|
802 | print FH $data or die "Can't write to FH: $!";
|
---|
803 |
|
---|
804 | This means that it short-circuits: i.e., the right expression is evaluated
|
---|
805 | only if the left expression is false. Due to its precedence, you should
|
---|
806 | probably avoid using this for assignment, only for control flow.
|
---|
807 |
|
---|
808 | $a = $b or $c; # bug: this is wrong
|
---|
809 | ($a = $b) or $c; # really means this
|
---|
810 | $a = $b || $c; # better written this way
|
---|
811 |
|
---|
812 | However, when it's a list-context assignment and you're trying to use
|
---|
813 | "||" for control flow, you probably need "or" so that the assignment
|
---|
814 | takes higher precedence.
|
---|
815 |
|
---|
816 | @info = stat($file) || die; # oops, scalar sense of stat!
|
---|
817 | @info = stat($file) or die; # better, now @info gets its due
|
---|
818 |
|
---|
819 | Then again, you could always use parentheses.
|
---|
820 |
|
---|
821 | Binary "xor" returns the exclusive-OR of the two surrounding expressions.
|
---|
822 | It cannot short circuit, of course.
|
---|
823 |
|
---|
824 | =head2 C Operators Missing From Perl
|
---|
825 | X<operator, missing from perl> X<&> X<*>
|
---|
826 | X<typecasting> X<(TYPE)>
|
---|
827 |
|
---|
828 | Here is what C has that Perl doesn't:
|
---|
829 |
|
---|
830 | =over 8
|
---|
831 |
|
---|
832 | =item unary &
|
---|
833 |
|
---|
834 | Address-of operator. (But see the "\" operator for taking a reference.)
|
---|
835 |
|
---|
836 | =item unary *
|
---|
837 |
|
---|
838 | Dereference-address operator. (Perl's prefix dereferencing
|
---|
839 | operators are typed: $, @, %, and &.)
|
---|
840 |
|
---|
841 | =item (TYPE)
|
---|
842 |
|
---|
843 | Type-casting operator.
|
---|
844 |
|
---|
845 | =back
|
---|
846 |
|
---|
847 | =head2 Quote and Quote-like Operators
|
---|
848 | X<operator, quote> X<operator, quote-like> X<q> X<qq> X<qx> X<qw> X<m>
|
---|
849 | X<qr> X<s> X<tr> X<'> X<''> X<"> X<""> X<//> X<`> X<``> X<<< << >>>
|
---|
850 | X<escape sequence> X<escape>
|
---|
851 |
|
---|
852 |
|
---|
853 | While we usually think of quotes as literal values, in Perl they
|
---|
854 | function as operators, providing various kinds of interpolating and
|
---|
855 | pattern matching capabilities. Perl provides customary quote characters
|
---|
856 | for these behaviors, but also provides a way for you to choose your
|
---|
857 | quote character for any of them. In the following table, a C<{}> represents
|
---|
858 | any pair of delimiters you choose.
|
---|
859 |
|
---|
860 | Customary Generic Meaning Interpolates
|
---|
861 | '' q{} Literal no
|
---|
862 | "" qq{} Literal yes
|
---|
863 | `` qx{} Command yes*
|
---|
864 | qw{} Word list no
|
---|
865 | // m{} Pattern match yes*
|
---|
866 | qr{} Pattern yes*
|
---|
867 | s{}{} Substitution yes*
|
---|
868 | tr{}{} Transliteration no (but see below)
|
---|
869 | <<EOF here-doc yes*
|
---|
870 |
|
---|
871 | * unless the delimiter is ''.
|
---|
872 |
|
---|
873 | Non-bracketing delimiters use the same character fore and aft, but the four
|
---|
874 | sorts of brackets (round, angle, square, curly) will all nest, which means
|
---|
875 | that
|
---|
876 |
|
---|
877 | q{foo{bar}baz}
|
---|
878 |
|
---|
879 | is the same as
|
---|
880 |
|
---|
881 | 'foo{bar}baz'
|
---|
882 |
|
---|
883 | Note, however, that this does not always work for quoting Perl code:
|
---|
884 |
|
---|
885 | $s = q{ if($a eq "}") ... }; # WRONG
|
---|
886 |
|
---|
887 | is a syntax error. The C<Text::Balanced> module (from CPAN, and
|
---|
888 | starting from Perl 5.8 part of the standard distribution) is able
|
---|
889 | to do this properly.
|
---|
890 |
|
---|
891 | There can be whitespace between the operator and the quoting
|
---|
892 | characters, except when C<#> is being used as the quoting character.
|
---|
893 | C<q#foo#> is parsed as the string C<foo>, while C<q #foo#> is the
|
---|
894 | operator C<q> followed by a comment. Its argument will be taken
|
---|
895 | from the next line. This allows you to write:
|
---|
896 |
|
---|
897 | s {foo} # Replace foo
|
---|
898 | {bar} # with bar.
|
---|
899 |
|
---|
900 | The following escape sequences are available in constructs that interpolate
|
---|
901 | and in transliterations.
|
---|
902 | X<\t> X<\n> X<\r> X<\f> X<\b> X<\a> X<\e> X<\x> X<\0> X<\c> X<\N>
|
---|
903 |
|
---|
904 | \t tab (HT, TAB)
|
---|
905 | \n newline (NL)
|
---|
906 | \r return (CR)
|
---|
907 | \f form feed (FF)
|
---|
908 | \b backspace (BS)
|
---|
909 | \a alarm (bell) (BEL)
|
---|
910 | \e escape (ESC)
|
---|
911 | \033 octal char (ESC)
|
---|
912 | \x1b hex char (ESC)
|
---|
913 | \x{263a} wide hex char (SMILEY)
|
---|
914 | \c[ control char (ESC)
|
---|
915 | \N{name} named Unicode character
|
---|
916 |
|
---|
917 | B<NOTE>: Unlike C and other languages, Perl has no \v escape sequence for
|
---|
918 | the vertical tab (VT - ASCII 11).
|
---|
919 |
|
---|
920 | The following escape sequences are available in constructs that interpolate
|
---|
921 | but not in transliterations.
|
---|
922 | X<\l> X<\u> X<\L> X<\U> X<\E> X<\Q>
|
---|
923 |
|
---|
924 | \l lowercase next char
|
---|
925 | \u uppercase next char
|
---|
926 | \L lowercase till \E
|
---|
927 | \U uppercase till \E
|
---|
928 | \E end case modification
|
---|
929 | \Q quote non-word characters till \E
|
---|
930 |
|
---|
931 | If C<use locale> is in effect, the case map used by C<\l>, C<\L>,
|
---|
932 | C<\u> and C<\U> is taken from the current locale. See L<perllocale>.
|
---|
933 | If Unicode (for example, C<\N{}> or wide hex characters of 0x100 or
|
---|
934 | beyond) is being used, the case map used by C<\l>, C<\L>, C<\u> and
|
---|
935 | C<\U> is as defined by Unicode. For documentation of C<\N{name}>,
|
---|
936 | see L<charnames>.
|
---|
937 |
|
---|
938 | All systems use the virtual C<"\n"> to represent a line terminator,
|
---|
939 | called a "newline". There is no such thing as an unvarying, physical
|
---|
940 | newline character. It is only an illusion that the operating system,
|
---|
941 | device drivers, C libraries, and Perl all conspire to preserve. Not all
|
---|
942 | systems read C<"\r"> as ASCII CR and C<"\n"> as ASCII LF. For example,
|
---|
943 | on a Mac, these are reversed, and on systems without line terminator,
|
---|
944 | printing C<"\n"> may emit no actual data. In general, use C<"\n"> when
|
---|
945 | you mean a "newline" for your system, but use the literal ASCII when you
|
---|
946 | need an exact character. For example, most networking protocols expect
|
---|
947 | and prefer a CR+LF (C<"\015\012"> or C<"\cM\cJ">) for line terminators,
|
---|
948 | and although they often accept just C<"\012">, they seldom tolerate just
|
---|
949 | C<"\015">. If you get in the habit of using C<"\n"> for networking,
|
---|
950 | you may be burned some day.
|
---|
951 | X<newline> X<line terminator> X<eol> X<end of line>
|
---|
952 | X<\n> X<\r> X<\r\n>
|
---|
953 |
|
---|
954 | For constructs that do interpolate, variables beginning with "C<$>"
|
---|
955 | or "C<@>" are interpolated. Subscripted variables such as C<$a[3]> or
|
---|
956 | C<< $href->{key}[0] >> are also interpolated, as are array and hash slices.
|
---|
957 | But method calls such as C<< $obj->meth >> are not.
|
---|
958 |
|
---|
959 | Interpolating an array or slice interpolates the elements in order,
|
---|
960 | separated by the value of C<$">, so is equivalent to interpolating
|
---|
961 | C<join $", @array>. "Punctuation" arrays such as C<@+> are only
|
---|
962 | interpolated if the name is enclosed in braces C<@{+}>.
|
---|
963 |
|
---|
964 | You cannot include a literal C<$> or C<@> within a C<\Q> sequence.
|
---|
965 | An unescaped C<$> or C<@> interpolates the corresponding variable,
|
---|
966 | while escaping will cause the literal string C<\$> to be inserted.
|
---|
967 | You'll need to write something like C<m/\Quser\E\@\Qhost/>.
|
---|
968 |
|
---|
969 | Patterns are subject to an additional level of interpretation as a
|
---|
970 | regular expression. This is done as a second pass, after variables are
|
---|
971 | interpolated, so that regular expressions may be incorporated into the
|
---|
972 | pattern from the variables. If this is not what you want, use C<\Q> to
|
---|
973 | interpolate a variable literally.
|
---|
974 |
|
---|
975 | Apart from the behavior described above, Perl does not expand
|
---|
976 | multiple levels of interpolation. In particular, contrary to the
|
---|
977 | expectations of shell programmers, back-quotes do I<NOT> interpolate
|
---|
978 | within double quotes, nor do single quotes impede evaluation of
|
---|
979 | variables when used within double quotes.
|
---|
980 |
|
---|
981 | =head2 Regexp Quote-Like Operators
|
---|
982 | X<operator, regexp>
|
---|
983 |
|
---|
984 | Here are the quote-like operators that apply to pattern
|
---|
985 | matching and related activities.
|
---|
986 |
|
---|
987 | =over 8
|
---|
988 |
|
---|
989 | =item ?PATTERN?
|
---|
990 | X<?>
|
---|
991 |
|
---|
992 | This is just like the C</pattern/> search, except that it matches only
|
---|
993 | once between calls to the reset() operator. This is a useful
|
---|
994 | optimization when you want to see only the first occurrence of
|
---|
995 | something in each file of a set of files, for instance. Only C<??>
|
---|
996 | patterns local to the current package are reset.
|
---|
997 |
|
---|
998 | while (<>) {
|
---|
999 | if (?^$?) {
|
---|
1000 | # blank line between header and body
|
---|
1001 | }
|
---|
1002 | } continue {
|
---|
1003 | reset if eof; # clear ?? status for next file
|
---|
1004 | }
|
---|
1005 |
|
---|
1006 | This usage is vaguely deprecated, which means it just might possibly
|
---|
1007 | be removed in some distant future version of Perl, perhaps somewhere
|
---|
1008 | around the year 2168.
|
---|
1009 |
|
---|
1010 | =item m/PATTERN/cgimosx
|
---|
1011 | X<m> X<operator, match>
|
---|
1012 | X<regexp, options> X<regexp> X<regex, options> X<regex>
|
---|
1013 | X</c> X</i> X</m> X</o> X</s> X</x>
|
---|
1014 |
|
---|
1015 | =item /PATTERN/cgimosx
|
---|
1016 |
|
---|
1017 | Searches a string for a pattern match, and in scalar context returns
|
---|
1018 | true if it succeeds, false if it fails. If no string is specified
|
---|
1019 | via the C<=~> or C<!~> operator, the $_ string is searched. (The
|
---|
1020 | string specified with C<=~> need not be an lvalue--it may be the
|
---|
1021 | result of an expression evaluation, but remember the C<=~> binds
|
---|
1022 | rather tightly.) See also L<perlre>. See L<perllocale> for
|
---|
1023 | discussion of additional considerations that apply when C<use locale>
|
---|
1024 | is in effect.
|
---|
1025 |
|
---|
1026 | Options are:
|
---|
1027 |
|
---|
1028 | c Do not reset search position on a failed match when /g is in effect.
|
---|
1029 | g Match globally, i.e., find all occurrences.
|
---|
1030 | i Do case-insensitive pattern matching.
|
---|
1031 | m Treat string as multiple lines.
|
---|
1032 | o Compile pattern only once.
|
---|
1033 | s Treat string as single line.
|
---|
1034 | x Use extended regular expressions.
|
---|
1035 |
|
---|
1036 | If "/" is the delimiter then the initial C<m> is optional. With the C<m>
|
---|
1037 | you can use any pair of non-alphanumeric, non-whitespace characters
|
---|
1038 | as delimiters. This is particularly useful for matching path names
|
---|
1039 | that contain "/", to avoid LTS (leaning toothpick syndrome). If "?" is
|
---|
1040 | the delimiter, then the match-only-once rule of C<?PATTERN?> applies.
|
---|
1041 | If "'" is the delimiter, no interpolation is performed on the PATTERN.
|
---|
1042 |
|
---|
1043 | PATTERN may contain variables, which will be interpolated (and the
|
---|
1044 | pattern recompiled) every time the pattern search is evaluated, except
|
---|
1045 | for when the delimiter is a single quote. (Note that C<$(>, C<$)>, and
|
---|
1046 | C<$|> are not interpolated because they look like end-of-string tests.)
|
---|
1047 | If you want such a pattern to be compiled only once, add a C</o> after
|
---|
1048 | the trailing delimiter. This avoids expensive run-time recompilations,
|
---|
1049 | and is useful when the value you are interpolating won't change over
|
---|
1050 | the life of the script. However, mentioning C</o> constitutes a promise
|
---|
1051 | that you won't change the variables in the pattern. If you change them,
|
---|
1052 | Perl won't even notice. See also L<"qr/STRING/imosx">.
|
---|
1053 |
|
---|
1054 | If the PATTERN evaluates to the empty string, the last
|
---|
1055 | I<successfully> matched regular expression is used instead. In this
|
---|
1056 | case, only the C<g> and C<c> flags on the empty pattern is honoured -
|
---|
1057 | the other flags are taken from the original pattern. If no match has
|
---|
1058 | previously succeeded, this will (silently) act instead as a genuine
|
---|
1059 | empty pattern (which will always match).
|
---|
1060 |
|
---|
1061 | If the C</g> option is not used, C<m//> in list context returns a
|
---|
1062 | list consisting of the subexpressions matched by the parentheses in the
|
---|
1063 | pattern, i.e., (C<$1>, C<$2>, C<$3>...). (Note that here C<$1> etc. are
|
---|
1064 | also set, and that this differs from Perl 4's behavior.) When there are
|
---|
1065 | no parentheses in the pattern, the return value is the list C<(1)> for
|
---|
1066 | success. With or without parentheses, an empty list is returned upon
|
---|
1067 | failure.
|
---|
1068 |
|
---|
1069 | Examples:
|
---|
1070 |
|
---|
1071 | open(TTY, '/dev/tty');
|
---|
1072 | <TTY> =~ /^y/i && foo(); # do foo if desired
|
---|
1073 |
|
---|
1074 | if (/Version: *([0-9.]*)/) { $version = $1; }
|
---|
1075 |
|
---|
1076 | next if m#^/usr/spool/uucp#;
|
---|
1077 |
|
---|
1078 | # poor man's grep
|
---|
1079 | $arg = shift;
|
---|
1080 | while (<>) {
|
---|
1081 | print if /$arg/o; # compile only once
|
---|
1082 | }
|
---|
1083 |
|
---|
1084 | if (($F1, $F2, $Etc) = ($foo =~ /^(\S+)\s+(\S+)\s*(.*)/))
|
---|
1085 |
|
---|
1086 | This last example splits $foo into the first two words and the
|
---|
1087 | remainder of the line, and assigns those three fields to $F1, $F2, and
|
---|
1088 | $Etc. The conditional is true if any variables were assigned, i.e., if
|
---|
1089 | the pattern matched.
|
---|
1090 |
|
---|
1091 | The C</g> modifier specifies global pattern matching--that is,
|
---|
1092 | matching as many times as possible within the string. How it behaves
|
---|
1093 | depends on the context. In list context, it returns a list of the
|
---|
1094 | substrings matched by any capturing parentheses in the regular
|
---|
1095 | expression. If there are no parentheses, it returns a list of all
|
---|
1096 | the matched strings, as if there were parentheses around the whole
|
---|
1097 | pattern.
|
---|
1098 |
|
---|
1099 | In scalar context, each execution of C<m//g> finds the next match,
|
---|
1100 | returning true if it matches, and false if there is no further match.
|
---|
1101 | The position after the last match can be read or set using the pos()
|
---|
1102 | function; see L<perlfunc/pos>. A failed match normally resets the
|
---|
1103 | search position to the beginning of the string, but you can avoid that
|
---|
1104 | by adding the C</c> modifier (e.g. C<m//gc>). Modifying the target
|
---|
1105 | string also resets the search position.
|
---|
1106 |
|
---|
1107 | You can intermix C<m//g> matches with C<m/\G.../g>, where C<\G> is a
|
---|
1108 | zero-width assertion that matches the exact position where the previous
|
---|
1109 | C<m//g>, if any, left off. Without the C</g> modifier, the C<\G> assertion
|
---|
1110 | still anchors at pos(), but the match is of course only attempted once.
|
---|
1111 | Using C<\G> without C</g> on a target string that has not previously had a
|
---|
1112 | C</g> match applied to it is the same as using the C<\A> assertion to match
|
---|
1113 | the beginning of the string. Note also that, currently, C<\G> is only
|
---|
1114 | properly supported when anchored at the very beginning of the pattern.
|
---|
1115 |
|
---|
1116 | Examples:
|
---|
1117 |
|
---|
1118 | # list context
|
---|
1119 | ($one,$five,$fifteen) = (`uptime` =~ /(\d+\.\d+)/g);
|
---|
1120 |
|
---|
1121 | # scalar context
|
---|
1122 | $/ = "";
|
---|
1123 | while (defined($paragraph = <>)) {
|
---|
1124 | while ($paragraph =~ /[a-z]['")]*[.!?]+['")]*\s/g) {
|
---|
1125 | $sentences++;
|
---|
1126 | }
|
---|
1127 | }
|
---|
1128 | print "$sentences\n";
|
---|
1129 |
|
---|
1130 | # using m//gc with \G
|
---|
1131 | $_ = "ppooqppqq";
|
---|
1132 | while ($i++ < 2) {
|
---|
1133 | print "1: '";
|
---|
1134 | print $1 while /(o)/gc; print "', pos=", pos, "\n";
|
---|
1135 | print "2: '";
|
---|
1136 | print $1 if /\G(q)/gc; print "', pos=", pos, "\n";
|
---|
1137 | print "3: '";
|
---|
1138 | print $1 while /(p)/gc; print "', pos=", pos, "\n";
|
---|
1139 | }
|
---|
1140 | print "Final: '$1', pos=",pos,"\n" if /\G(.)/;
|
---|
1141 |
|
---|
1142 | The last example should print:
|
---|
1143 |
|
---|
1144 | 1: 'oo', pos=4
|
---|
1145 | 2: 'q', pos=5
|
---|
1146 | 3: 'pp', pos=7
|
---|
1147 | 1: '', pos=7
|
---|
1148 | 2: 'q', pos=8
|
---|
1149 | 3: '', pos=8
|
---|
1150 | Final: 'q', pos=8
|
---|
1151 |
|
---|
1152 | Notice that the final match matched C<q> instead of C<p>, which a match
|
---|
1153 | without the C<\G> anchor would have done. Also note that the final match
|
---|
1154 | did not update C<pos> -- C<pos> is only updated on a C</g> match. If the
|
---|
1155 | final match did indeed match C<p>, it's a good bet that you're running an
|
---|
1156 | older (pre-5.6.0) Perl.
|
---|
1157 |
|
---|
1158 | A useful idiom for C<lex>-like scanners is C</\G.../gc>. You can
|
---|
1159 | combine several regexps like this to process a string part-by-part,
|
---|
1160 | doing different actions depending on which regexp matched. Each
|
---|
1161 | regexp tries to match where the previous one leaves off.
|
---|
1162 |
|
---|
1163 | $_ = <<'EOL';
|
---|
1164 | $url = new URI::URL "http://www/"; die if $url eq "xXx";
|
---|
1165 | EOL
|
---|
1166 | LOOP:
|
---|
1167 | {
|
---|
1168 | print(" digits"), redo LOOP if /\G\d+\b[,.;]?\s*/gc;
|
---|
1169 | print(" lowercase"), redo LOOP if /\G[a-z]+\b[,.;]?\s*/gc;
|
---|
1170 | print(" UPPERCASE"), redo LOOP if /\G[A-Z]+\b[,.;]?\s*/gc;
|
---|
1171 | print(" Capitalized"), redo LOOP if /\G[A-Z][a-z]+\b[,.;]?\s*/gc;
|
---|
1172 | print(" MiXeD"), redo LOOP if /\G[A-Za-z]+\b[,.;]?\s*/gc;
|
---|
1173 | print(" alphanumeric"), redo LOOP if /\G[A-Za-z0-9]+\b[,.;]?\s*/gc;
|
---|
1174 | print(" line-noise"), redo LOOP if /\G[^A-Za-z0-9]+/gc;
|
---|
1175 | print ". That's all!\n";
|
---|
1176 | }
|
---|
1177 |
|
---|
1178 | Here is the output (split into several lines):
|
---|
1179 |
|
---|
1180 | line-noise lowercase line-noise lowercase UPPERCASE line-noise
|
---|
1181 | UPPERCASE line-noise lowercase line-noise lowercase line-noise
|
---|
1182 | lowercase lowercase line-noise lowercase lowercase line-noise
|
---|
1183 | MiXeD line-noise. That's all!
|
---|
1184 |
|
---|
1185 | =item q/STRING/
|
---|
1186 | X<q> X<quote, double> X<'> X<''>
|
---|
1187 |
|
---|
1188 | =item C<'STRING'>
|
---|
1189 |
|
---|
1190 | A single-quoted, literal string. A backslash represents a backslash
|
---|
1191 | unless followed by the delimiter or another backslash, in which case
|
---|
1192 | the delimiter or backslash is interpolated.
|
---|
1193 |
|
---|
1194 | $foo = q!I said, "You said, 'She said it.'"!;
|
---|
1195 | $bar = q('This is it.');
|
---|
1196 | $baz = '\n'; # a two-character string
|
---|
1197 |
|
---|
1198 | =item qq/STRING/
|
---|
1199 | X<qq> X<quote, double> X<"> X<"">
|
---|
1200 |
|
---|
1201 | =item "STRING"
|
---|
1202 |
|
---|
1203 | A double-quoted, interpolated string.
|
---|
1204 |
|
---|
1205 | $_ .= qq
|
---|
1206 | (*** The previous line contains the naughty word "$1".\n)
|
---|
1207 | if /\b(tcl|java|python)\b/i; # :-)
|
---|
1208 | $baz = "\n"; # a one-character string
|
---|
1209 |
|
---|
1210 | =item qr/STRING/imosx
|
---|
1211 | X<qr> X</i> X</m> X</o> X</s> X</x>
|
---|
1212 |
|
---|
1213 | This operator quotes (and possibly compiles) its I<STRING> as a regular
|
---|
1214 | expression. I<STRING> is interpolated the same way as I<PATTERN>
|
---|
1215 | in C<m/PATTERN/>. If "'" is used as the delimiter, no interpolation
|
---|
1216 | is done. Returns a Perl value which may be used instead of the
|
---|
1217 | corresponding C</STRING/imosx> expression.
|
---|
1218 |
|
---|
1219 | For example,
|
---|
1220 |
|
---|
1221 | $rex = qr/my.STRING/is;
|
---|
1222 | s/$rex/foo/;
|
---|
1223 |
|
---|
1224 | is equivalent to
|
---|
1225 |
|
---|
1226 | s/my.STRING/foo/is;
|
---|
1227 |
|
---|
1228 | The result may be used as a subpattern in a match:
|
---|
1229 |
|
---|
1230 | $re = qr/$pattern/;
|
---|
1231 | $string =~ /foo${re}bar/; # can be interpolated in other patterns
|
---|
1232 | $string =~ $re; # or used standalone
|
---|
1233 | $string =~ /$re/; # or this way
|
---|
1234 |
|
---|
1235 | Since Perl may compile the pattern at the moment of execution of qr()
|
---|
1236 | operator, using qr() may have speed advantages in some situations,
|
---|
1237 | notably if the result of qr() is used standalone:
|
---|
1238 |
|
---|
1239 | sub match {
|
---|
1240 | my $patterns = shift;
|
---|
1241 | my @compiled = map qr/$_/i, @$patterns;
|
---|
1242 | grep {
|
---|
1243 | my $success = 0;
|
---|
1244 | foreach my $pat (@compiled) {
|
---|
1245 | $success = 1, last if /$pat/;
|
---|
1246 | }
|
---|
1247 | $success;
|
---|
1248 | } @_;
|
---|
1249 | }
|
---|
1250 |
|
---|
1251 | Precompilation of the pattern into an internal representation at
|
---|
1252 | the moment of qr() avoids a need to recompile the pattern every
|
---|
1253 | time a match C</$pat/> is attempted. (Perl has many other internal
|
---|
1254 | optimizations, but none would be triggered in the above example if
|
---|
1255 | we did not use qr() operator.)
|
---|
1256 |
|
---|
1257 | Options are:
|
---|
1258 |
|
---|
1259 | i Do case-insensitive pattern matching.
|
---|
1260 | m Treat string as multiple lines.
|
---|
1261 | o Compile pattern only once.
|
---|
1262 | s Treat string as single line.
|
---|
1263 | x Use extended regular expressions.
|
---|
1264 |
|
---|
1265 | See L<perlre> for additional information on valid syntax for STRING, and
|
---|
1266 | for a detailed look at the semantics of regular expressions.
|
---|
1267 |
|
---|
1268 | =item qx/STRING/
|
---|
1269 | X<qx> X<`> X<``> X<backtick>
|
---|
1270 |
|
---|
1271 | =item `STRING`
|
---|
1272 |
|
---|
1273 | A string which is (possibly) interpolated and then executed as a
|
---|
1274 | system command with C</bin/sh> or its equivalent. Shell wildcards,
|
---|
1275 | pipes, and redirections will be honored. The collected standard
|
---|
1276 | output of the command is returned; standard error is unaffected. In
|
---|
1277 | scalar context, it comes back as a single (potentially multi-line)
|
---|
1278 | string, or undef if the command failed. In list context, returns a
|
---|
1279 | list of lines (however you've defined lines with $/ or
|
---|
1280 | $INPUT_RECORD_SEPARATOR), or an empty list if the command failed.
|
---|
1281 |
|
---|
1282 | Because backticks do not affect standard error, use shell file descriptor
|
---|
1283 | syntax (assuming the shell supports this) if you care to address this.
|
---|
1284 | To capture a command's STDERR and STDOUT together:
|
---|
1285 |
|
---|
1286 | $output = `cmd 2>&1`;
|
---|
1287 |
|
---|
1288 | To capture a command's STDOUT but discard its STDERR:
|
---|
1289 |
|
---|
1290 | $output = `cmd 2>/dev/null`;
|
---|
1291 |
|
---|
1292 | To capture a command's STDERR but discard its STDOUT (ordering is
|
---|
1293 | important here):
|
---|
1294 |
|
---|
1295 | $output = `cmd 2>&1 1>/dev/null`;
|
---|
1296 |
|
---|
1297 | To exchange a command's STDOUT and STDERR in order to capture the STDERR
|
---|
1298 | but leave its STDOUT to come out the old STDERR:
|
---|
1299 |
|
---|
1300 | $output = `cmd 3>&1 1>&2 2>&3 3>&-`;
|
---|
1301 |
|
---|
1302 | To read both a command's STDOUT and its STDERR separately, it's easiest
|
---|
1303 | to redirect them separately to files, and then read from those files
|
---|
1304 | when the program is done:
|
---|
1305 |
|
---|
1306 | system("program args 1>program.stdout 2>program.stderr");
|
---|
1307 |
|
---|
1308 | Using single-quote as a delimiter protects the command from Perl's
|
---|
1309 | double-quote interpolation, passing it on to the shell instead:
|
---|
1310 |
|
---|
1311 | $perl_info = qx(ps $$); # that's Perl's $$
|
---|
1312 | $shell_info = qx'ps $$'; # that's the new shell's $$
|
---|
1313 |
|
---|
1314 | How that string gets evaluated is entirely subject to the command
|
---|
1315 | interpreter on your system. On most platforms, you will have to protect
|
---|
1316 | shell metacharacters if you want them treated literally. This is in
|
---|
1317 | practice difficult to do, as it's unclear how to escape which characters.
|
---|
1318 | See L<perlsec> for a clean and safe example of a manual fork() and exec()
|
---|
1319 | to emulate backticks safely.
|
---|
1320 |
|
---|
1321 | On some platforms (notably DOS-like ones), the shell may not be
|
---|
1322 | capable of dealing with multiline commands, so putting newlines in
|
---|
1323 | the string may not get you what you want. You may be able to evaluate
|
---|
1324 | multiple commands in a single line by separating them with the command
|
---|
1325 | separator character, if your shell supports that (e.g. C<;> on many Unix
|
---|
1326 | shells; C<&> on the Windows NT C<cmd> shell).
|
---|
1327 |
|
---|
1328 | Beginning with v5.6.0, Perl will attempt to flush all files opened for
|
---|
1329 | output before starting the child process, but this may not be supported
|
---|
1330 | on some platforms (see L<perlport>). To be safe, you may need to set
|
---|
1331 | C<$|> ($AUTOFLUSH in English) or call the C<autoflush()> method of
|
---|
1332 | C<IO::Handle> on any open handles.
|
---|
1333 |
|
---|
1334 | Beware that some command shells may place restrictions on the length
|
---|
1335 | of the command line. You must ensure your strings don't exceed this
|
---|
1336 | limit after any necessary interpolations. See the platform-specific
|
---|
1337 | release notes for more details about your particular environment.
|
---|
1338 |
|
---|
1339 | Using this operator can lead to programs that are difficult to port,
|
---|
1340 | because the shell commands called vary between systems, and may in
|
---|
1341 | fact not be present at all. As one example, the C<type> command under
|
---|
1342 | the POSIX shell is very different from the C<type> command under DOS.
|
---|
1343 | That doesn't mean you should go out of your way to avoid backticks
|
---|
1344 | when they're the right way to get something done. Perl was made to be
|
---|
1345 | a glue language, and one of the things it glues together is commands.
|
---|
1346 | Just understand what you're getting yourself into.
|
---|
1347 |
|
---|
1348 | See L<"I/O Operators"> for more discussion.
|
---|
1349 |
|
---|
1350 | =item qw/STRING/
|
---|
1351 | X<qw> X<quote, list> X<quote, words>
|
---|
1352 |
|
---|
1353 | Evaluates to a list of the words extracted out of STRING, using embedded
|
---|
1354 | whitespace as the word delimiters. It can be understood as being roughly
|
---|
1355 | equivalent to:
|
---|
1356 |
|
---|
1357 | split(' ', q/STRING/);
|
---|
1358 |
|
---|
1359 | the differences being that it generates a real list at compile time, and
|
---|
1360 | in scalar context it returns the last element in the list. So
|
---|
1361 | this expression:
|
---|
1362 |
|
---|
1363 | qw(foo bar baz)
|
---|
1364 |
|
---|
1365 | is semantically equivalent to the list:
|
---|
1366 |
|
---|
1367 | 'foo', 'bar', 'baz'
|
---|
1368 |
|
---|
1369 | Some frequently seen examples:
|
---|
1370 |
|
---|
1371 | use POSIX qw( setlocale localeconv )
|
---|
1372 | @EXPORT = qw( foo bar baz );
|
---|
1373 |
|
---|
1374 | A common mistake is to try to separate the words with comma or to
|
---|
1375 | put comments into a multi-line C<qw>-string. For this reason, the
|
---|
1376 | C<use warnings> pragma and the B<-w> switch (that is, the C<$^W> variable)
|
---|
1377 | produces warnings if the STRING contains the "," or the "#" character.
|
---|
1378 |
|
---|
1379 | =item s/PATTERN/REPLACEMENT/egimosx
|
---|
1380 | X<substitute> X<substitution> X<replace> X<regexp, replace>
|
---|
1381 | X<regexp, substitute> X</e> X</g> X</i> X</m> X</o> X</s> X</x>
|
---|
1382 |
|
---|
1383 | Searches a string for a pattern, and if found, replaces that pattern
|
---|
1384 | with the replacement text and returns the number of substitutions
|
---|
1385 | made. Otherwise it returns false (specifically, the empty string).
|
---|
1386 |
|
---|
1387 | If no string is specified via the C<=~> or C<!~> operator, the C<$_>
|
---|
1388 | variable is searched and modified. (The string specified with C<=~> must
|
---|
1389 | be scalar variable, an array element, a hash element, or an assignment
|
---|
1390 | to one of those, i.e., an lvalue.)
|
---|
1391 |
|
---|
1392 | If the delimiter chosen is a single quote, no interpolation is
|
---|
1393 | done on either the PATTERN or the REPLACEMENT. Otherwise, if the
|
---|
1394 | PATTERN contains a $ that looks like a variable rather than an
|
---|
1395 | end-of-string test, the variable will be interpolated into the pattern
|
---|
1396 | at run-time. If you want the pattern compiled only once the first time
|
---|
1397 | the variable is interpolated, use the C</o> option. If the pattern
|
---|
1398 | evaluates to the empty string, the last successfully executed regular
|
---|
1399 | expression is used instead. See L<perlre> for further explanation on these.
|
---|
1400 | See L<perllocale> for discussion of additional considerations that apply
|
---|
1401 | when C<use locale> is in effect.
|
---|
1402 |
|
---|
1403 | Options are:
|
---|
1404 |
|
---|
1405 | e Evaluate the right side as an expression.
|
---|
1406 | g Replace globally, i.e., all occurrences.
|
---|
1407 | i Do case-insensitive pattern matching.
|
---|
1408 | m Treat string as multiple lines.
|
---|
1409 | o Compile pattern only once.
|
---|
1410 | s Treat string as single line.
|
---|
1411 | x Use extended regular expressions.
|
---|
1412 |
|
---|
1413 | Any non-alphanumeric, non-whitespace delimiter may replace the
|
---|
1414 | slashes. If single quotes are used, no interpretation is done on the
|
---|
1415 | replacement string (the C</e> modifier overrides this, however). Unlike
|
---|
1416 | Perl 4, Perl 5 treats backticks as normal delimiters; the replacement
|
---|
1417 | text is not evaluated as a command. If the
|
---|
1418 | PATTERN is delimited by bracketing quotes, the REPLACEMENT has its own
|
---|
1419 | pair of quotes, which may or may not be bracketing quotes, e.g.,
|
---|
1420 | C<s(foo)(bar)> or C<< s<foo>/bar/ >>. A C</e> will cause the
|
---|
1421 | replacement portion to be treated as a full-fledged Perl expression
|
---|
1422 | and evaluated right then and there. It is, however, syntax checked at
|
---|
1423 | compile-time. A second C<e> modifier will cause the replacement portion
|
---|
1424 | to be C<eval>ed before being run as a Perl expression.
|
---|
1425 |
|
---|
1426 | Examples:
|
---|
1427 |
|
---|
1428 | s/\bgreen\b/mauve/g; # don't change wintergreen
|
---|
1429 |
|
---|
1430 | $path =~ s|/usr/bin|/usr/local/bin|;
|
---|
1431 |
|
---|
1432 | s/Login: $foo/Login: $bar/; # run-time pattern
|
---|
1433 |
|
---|
1434 | ($foo = $bar) =~ s/this/that/; # copy first, then change
|
---|
1435 |
|
---|
1436 | $count = ($paragraph =~ s/Mister\b/Mr./g); # get change-count
|
---|
1437 |
|
---|
1438 | $_ = 'abc123xyz';
|
---|
1439 | s/\d+/$&*2/e; # yields 'abc246xyz'
|
---|
1440 | s/\d+/sprintf("%5d",$&)/e; # yields 'abc 246xyz'
|
---|
1441 | s/\w/$& x 2/eg; # yields 'aabbcc 224466xxyyzz'
|
---|
1442 |
|
---|
1443 | s/%(.)/$percent{$1}/g; # change percent escapes; no /e
|
---|
1444 | s/%(.)/$percent{$1} || $&/ge; # expr now, so /e
|
---|
1445 | s/^=(\w+)/&pod($1)/ge; # use function call
|
---|
1446 |
|
---|
1447 | # expand variables in $_, but dynamics only, using
|
---|
1448 | # symbolic dereferencing
|
---|
1449 | s/\$(\w+)/${$1}/g;
|
---|
1450 |
|
---|
1451 | # Add one to the value of any numbers in the string
|
---|
1452 | s/(\d+)/1 + $1/eg;
|
---|
1453 |
|
---|
1454 | # This will expand any embedded scalar variable
|
---|
1455 | # (including lexicals) in $_ : First $1 is interpolated
|
---|
1456 | # to the variable name, and then evaluated
|
---|
1457 | s/(\$\w+)/$1/eeg;
|
---|
1458 |
|
---|
1459 | # Delete (most) C comments.
|
---|
1460 | $program =~ s {
|
---|
1461 | /\* # Match the opening delimiter.
|
---|
1462 | .*? # Match a minimal number of characters.
|
---|
1463 | \*/ # Match the closing delimiter.
|
---|
1464 | } []gsx;
|
---|
1465 |
|
---|
1466 | s/^\s*(.*?)\s*$/$1/; # trim whitespace in $_, expensively
|
---|
1467 |
|
---|
1468 | for ($variable) { # trim whitespace in $variable, cheap
|
---|
1469 | s/^\s+//;
|
---|
1470 | s/\s+$//;
|
---|
1471 | }
|
---|
1472 |
|
---|
1473 | s/([^ ]*) *([^ ]*)/$2 $1/; # reverse 1st two fields
|
---|
1474 |
|
---|
1475 | Note the use of $ instead of \ in the last example. Unlike
|
---|
1476 | B<sed>, we use the \<I<digit>> form in only the left hand side.
|
---|
1477 | Anywhere else it's $<I<digit>>.
|
---|
1478 |
|
---|
1479 | Occasionally, you can't use just a C</g> to get all the changes
|
---|
1480 | to occur that you might want. Here are two common cases:
|
---|
1481 |
|
---|
1482 | # put commas in the right places in an integer
|
---|
1483 | 1 while s/(\d)(\d\d\d)(?!\d)/$1,$2/g;
|
---|
1484 |
|
---|
1485 | # expand tabs to 8-column spacing
|
---|
1486 | 1 while s/\t+/' ' x (length($&)*8 - length($`)%8)/e;
|
---|
1487 |
|
---|
1488 | =item tr/SEARCHLIST/REPLACEMENTLIST/cds
|
---|
1489 | X<tr> X<y> X<transliterate> X</c> X</d> X</s>
|
---|
1490 |
|
---|
1491 | =item y/SEARCHLIST/REPLACEMENTLIST/cds
|
---|
1492 |
|
---|
1493 | Transliterates all occurrences of the characters found in the search list
|
---|
1494 | with the corresponding character in the replacement list. It returns
|
---|
1495 | the number of characters replaced or deleted. If no string is
|
---|
1496 | specified via the =~ or !~ operator, the $_ string is transliterated. (The
|
---|
1497 | string specified with =~ must be a scalar variable, an array element, a
|
---|
1498 | hash element, or an assignment to one of those, i.e., an lvalue.)
|
---|
1499 |
|
---|
1500 | A character range may be specified with a hyphen, so C<tr/A-J/0-9/>
|
---|
1501 | does the same replacement as C<tr/ACEGIBDFHJ/0246813579/>.
|
---|
1502 | For B<sed> devotees, C<y> is provided as a synonym for C<tr>. If the
|
---|
1503 | SEARCHLIST is delimited by bracketing quotes, the REPLACEMENTLIST has
|
---|
1504 | its own pair of quotes, which may or may not be bracketing quotes,
|
---|
1505 | e.g., C<tr[A-Z][a-z]> or C<tr(+\-*/)/ABCD/>.
|
---|
1506 |
|
---|
1507 | Note that C<tr> does B<not> do regular expression character classes
|
---|
1508 | such as C<\d> or C<[:lower:]>. The <tr> operator is not equivalent to
|
---|
1509 | the tr(1) utility. If you want to map strings between lower/upper
|
---|
1510 | cases, see L<perlfunc/lc> and L<perlfunc/uc>, and in general consider
|
---|
1511 | using the C<s> operator if you need regular expressions.
|
---|
1512 |
|
---|
1513 | Note also that the whole range idea is rather unportable between
|
---|
1514 | character sets--and even within character sets they may cause results
|
---|
1515 | you probably didn't expect. A sound principle is to use only ranges
|
---|
1516 | that begin from and end at either alphabets of equal case (a-e, A-E),
|
---|
1517 | or digits (0-4). Anything else is unsafe. If in doubt, spell out the
|
---|
1518 | character sets in full.
|
---|
1519 |
|
---|
1520 | Options:
|
---|
1521 |
|
---|
1522 | c Complement the SEARCHLIST.
|
---|
1523 | d Delete found but unreplaced characters.
|
---|
1524 | s Squash duplicate replaced characters.
|
---|
1525 |
|
---|
1526 | If the C</c> modifier is specified, the SEARCHLIST character set
|
---|
1527 | is complemented. If the C</d> modifier is specified, any characters
|
---|
1528 | specified by SEARCHLIST not found in REPLACEMENTLIST are deleted.
|
---|
1529 | (Note that this is slightly more flexible than the behavior of some
|
---|
1530 | B<tr> programs, which delete anything they find in the SEARCHLIST,
|
---|
1531 | period.) If the C</s> modifier is specified, sequences of characters
|
---|
1532 | that were transliterated to the same character are squashed down
|
---|
1533 | to a single instance of the character.
|
---|
1534 |
|
---|
1535 | If the C</d> modifier is used, the REPLACEMENTLIST is always interpreted
|
---|
1536 | exactly as specified. Otherwise, if the REPLACEMENTLIST is shorter
|
---|
1537 | than the SEARCHLIST, the final character is replicated till it is long
|
---|
1538 | enough. If the REPLACEMENTLIST is empty, the SEARCHLIST is replicated.
|
---|
1539 | This latter is useful for counting characters in a class or for
|
---|
1540 | squashing character sequences in a class.
|
---|
1541 |
|
---|
1542 | Examples:
|
---|
1543 |
|
---|
1544 | $ARGV[1] =~ tr/A-Z/a-z/; # canonicalize to lower case
|
---|
1545 |
|
---|
1546 | $cnt = tr/*/*/; # count the stars in $_
|
---|
1547 |
|
---|
1548 | $cnt = $sky =~ tr/*/*/; # count the stars in $sky
|
---|
1549 |
|
---|
1550 | $cnt = tr/0-9//; # count the digits in $_
|
---|
1551 |
|
---|
1552 | tr/a-zA-Z//s; # bookkeeper -> bokeper
|
---|
1553 |
|
---|
1554 | ($HOST = $host) =~ tr/a-z/A-Z/;
|
---|
1555 |
|
---|
1556 | tr/a-zA-Z/ /cs; # change non-alphas to single space
|
---|
1557 |
|
---|
1558 | tr [\200-\377]
|
---|
1559 | [\000-\177]; # delete 8th bit
|
---|
1560 |
|
---|
1561 | If multiple transliterations are given for a character, only the
|
---|
1562 | first one is used:
|
---|
1563 |
|
---|
1564 | tr/AAA/XYZ/
|
---|
1565 |
|
---|
1566 | will transliterate any A to X.
|
---|
1567 |
|
---|
1568 | Because the transliteration table is built at compile time, neither
|
---|
1569 | the SEARCHLIST nor the REPLACEMENTLIST are subjected to double quote
|
---|
1570 | interpolation. That means that if you want to use variables, you
|
---|
1571 | must use an eval():
|
---|
1572 |
|
---|
1573 | eval "tr/$oldlist/$newlist/";
|
---|
1574 | die $@ if $@;
|
---|
1575 |
|
---|
1576 | eval "tr/$oldlist/$newlist/, 1" or die $@;
|
---|
1577 |
|
---|
1578 | =item <<EOF
|
---|
1579 | X<here-doc> X<heredoc> X<here-document> X<<< << >>>
|
---|
1580 |
|
---|
1581 | A line-oriented form of quoting is based on the shell "here-document"
|
---|
1582 | syntax. Following a C<< << >> you specify a string to terminate
|
---|
1583 | the quoted material, and all lines following the current line down to
|
---|
1584 | the terminating string are the value of the item. The terminating
|
---|
1585 | string may be either an identifier (a word), or some quoted text. If
|
---|
1586 | quoted, the type of quotes you use determines the treatment of the
|
---|
1587 | text, just as in regular quoting. An unquoted identifier works like
|
---|
1588 | double quotes. There must be no space between the C<< << >> and
|
---|
1589 | the identifier, unless the identifier is quoted. (If you put a space it
|
---|
1590 | will be treated as a null identifier, which is valid, and matches the first
|
---|
1591 | empty line.) The terminating string must appear by itself (unquoted and
|
---|
1592 | with no surrounding whitespace) on the terminating line.
|
---|
1593 |
|
---|
1594 | print <<EOF;
|
---|
1595 | The price is $Price.
|
---|
1596 | EOF
|
---|
1597 |
|
---|
1598 | print << "EOF"; # same as above
|
---|
1599 | The price is $Price.
|
---|
1600 | EOF
|
---|
1601 |
|
---|
1602 | print << `EOC`; # execute commands
|
---|
1603 | echo hi there
|
---|
1604 | echo lo there
|
---|
1605 | EOC
|
---|
1606 |
|
---|
1607 | print <<"foo", <<"bar"; # you can stack them
|
---|
1608 | I said foo.
|
---|
1609 | foo
|
---|
1610 | I said bar.
|
---|
1611 | bar
|
---|
1612 |
|
---|
1613 | myfunc(<< "THIS", 23, <<'THAT');
|
---|
1614 | Here's a line
|
---|
1615 | or two.
|
---|
1616 | THIS
|
---|
1617 | and here's another.
|
---|
1618 | THAT
|
---|
1619 |
|
---|
1620 | Just don't forget that you have to put a semicolon on the end
|
---|
1621 | to finish the statement, as Perl doesn't know you're not going to
|
---|
1622 | try to do this:
|
---|
1623 |
|
---|
1624 | print <<ABC
|
---|
1625 | 179231
|
---|
1626 | ABC
|
---|
1627 | + 20;
|
---|
1628 |
|
---|
1629 | If you want your here-docs to be indented with the
|
---|
1630 | rest of the code, you'll need to remove leading whitespace
|
---|
1631 | from each line manually:
|
---|
1632 |
|
---|
1633 | ($quote = <<'FINIS') =~ s/^\s+//gm;
|
---|
1634 | The Road goes ever on and on,
|
---|
1635 | down from the door where it began.
|
---|
1636 | FINIS
|
---|
1637 |
|
---|
1638 | If you use a here-doc within a delimited construct, such as in C<s///eg>,
|
---|
1639 | the quoted material must come on the lines following the final delimiter.
|
---|
1640 | So instead of
|
---|
1641 |
|
---|
1642 | s/this/<<E . 'that'
|
---|
1643 | the other
|
---|
1644 | E
|
---|
1645 | . 'more '/eg;
|
---|
1646 |
|
---|
1647 | you have to write
|
---|
1648 |
|
---|
1649 | s/this/<<E . 'that'
|
---|
1650 | . 'more '/eg;
|
---|
1651 | the other
|
---|
1652 | E
|
---|
1653 |
|
---|
1654 | If the terminating identifier is on the last line of the program, you
|
---|
1655 | must be sure there is a newline after it; otherwise, Perl will give the
|
---|
1656 | warning B<Can't find string terminator "END" anywhere before EOF...>.
|
---|
1657 |
|
---|
1658 | Additionally, the quoting rules for the identifier are not related to
|
---|
1659 | Perl's quoting rules -- C<q()>, C<qq()>, and the like are not supported
|
---|
1660 | in place of C<''> and C<"">, and the only interpolation is for backslashing
|
---|
1661 | the quoting character:
|
---|
1662 |
|
---|
1663 | print << "abc\"def";
|
---|
1664 | testing...
|
---|
1665 | abc"def
|
---|
1666 |
|
---|
1667 | Finally, quoted strings cannot span multiple lines. The general rule is
|
---|
1668 | that the identifier must be a string literal. Stick with that, and you
|
---|
1669 | should be safe.
|
---|
1670 |
|
---|
1671 | =back
|
---|
1672 |
|
---|
1673 | =head2 Gory details of parsing quoted constructs
|
---|
1674 | X<quote, gory details>
|
---|
1675 |
|
---|
1676 | When presented with something that might have several different
|
---|
1677 | interpretations, Perl uses the B<DWIM> (that's "Do What I Mean")
|
---|
1678 | principle to pick the most probable interpretation. This strategy
|
---|
1679 | is so successful that Perl programmers often do not suspect the
|
---|
1680 | ambivalence of what they write. But from time to time, Perl's
|
---|
1681 | notions differ substantially from what the author honestly meant.
|
---|
1682 |
|
---|
1683 | This section hopes to clarify how Perl handles quoted constructs.
|
---|
1684 | Although the most common reason to learn this is to unravel labyrinthine
|
---|
1685 | regular expressions, because the initial steps of parsing are the
|
---|
1686 | same for all quoting operators, they are all discussed together.
|
---|
1687 |
|
---|
1688 | The most important Perl parsing rule is the first one discussed
|
---|
1689 | below: when processing a quoted construct, Perl first finds the end
|
---|
1690 | of that construct, then interprets its contents. If you understand
|
---|
1691 | this rule, you may skip the rest of this section on the first
|
---|
1692 | reading. The other rules are likely to contradict the user's
|
---|
1693 | expectations much less frequently than this first one.
|
---|
1694 |
|
---|
1695 | Some passes discussed below are performed concurrently, but because
|
---|
1696 | their results are the same, we consider them individually. For different
|
---|
1697 | quoting constructs, Perl performs different numbers of passes, from
|
---|
1698 | one to five, but these passes are always performed in the same order.
|
---|
1699 |
|
---|
1700 | =over 4
|
---|
1701 |
|
---|
1702 | =item Finding the end
|
---|
1703 |
|
---|
1704 | The first pass is finding the end of the quoted construct, whether
|
---|
1705 | it be a multicharacter delimiter C<"\nEOF\n"> in the C<<<EOF>
|
---|
1706 | construct, a C</> that terminates a C<qq//> construct, a C<]> which
|
---|
1707 | terminates C<qq[]> construct, or a C<< > >> which terminates a
|
---|
1708 | fileglob started with C<< < >>.
|
---|
1709 |
|
---|
1710 | When searching for single-character non-pairing delimiters, such
|
---|
1711 | as C</>, combinations of C<\\> and C<\/> are skipped. However,
|
---|
1712 | when searching for single-character pairing delimiter like C<[>,
|
---|
1713 | combinations of C<\\>, C<\]>, and C<\[> are all skipped, and nested
|
---|
1714 | C<[>, C<]> are skipped as well. When searching for multicharacter
|
---|
1715 | delimiters, nothing is skipped.
|
---|
1716 |
|
---|
1717 | For constructs with three-part delimiters (C<s///>, C<y///>, and
|
---|
1718 | C<tr///>), the search is repeated once more.
|
---|
1719 |
|
---|
1720 | During this search no attention is paid to the semantics of the construct.
|
---|
1721 | Thus:
|
---|
1722 |
|
---|
1723 | "$hash{"$foo/$bar"}"
|
---|
1724 |
|
---|
1725 | or:
|
---|
1726 |
|
---|
1727 | m/
|
---|
1728 | bar # NOT a comment, this slash / terminated m//!
|
---|
1729 | /x
|
---|
1730 |
|
---|
1731 | do not form legal quoted expressions. The quoted part ends on the
|
---|
1732 | first C<"> and C</>, and the rest happens to be a syntax error.
|
---|
1733 | Because the slash that terminated C<m//> was followed by a C<SPACE>,
|
---|
1734 | the example above is not C<m//x>, but rather C<m//> with no C</x>
|
---|
1735 | modifier. So the embedded C<#> is interpreted as a literal C<#>.
|
---|
1736 |
|
---|
1737 | Also no attention is paid to C<\c\> during this search.
|
---|
1738 | Thus the second C<\> in C<qq/\c\/> is interpreted as a part of C<\/>,
|
---|
1739 | and the following C</> is not recognized as a delimiter.
|
---|
1740 | Instead, use C<\034> or C<\x1c> at the end of quoted constructs.
|
---|
1741 |
|
---|
1742 | =item Removal of backslashes before delimiters
|
---|
1743 |
|
---|
1744 | During the second pass, text between the starting and ending
|
---|
1745 | delimiters is copied to a safe location, and the C<\> is removed
|
---|
1746 | from combinations consisting of C<\> and delimiter--or delimiters,
|
---|
1747 | meaning both starting and ending delimiters will should these differ.
|
---|
1748 | This removal does not happen for multi-character delimiters.
|
---|
1749 | Note that the combination C<\\> is left intact, just as it was.
|
---|
1750 |
|
---|
1751 | Starting from this step no information about the delimiters is
|
---|
1752 | used in parsing.
|
---|
1753 |
|
---|
1754 | =item Interpolation
|
---|
1755 | X<interpolation>
|
---|
1756 |
|
---|
1757 | The next step is interpolation in the text obtained, which is now
|
---|
1758 | delimiter-independent. There are four different cases.
|
---|
1759 |
|
---|
1760 | =over 4
|
---|
1761 |
|
---|
1762 | =item C<<<'EOF'>, C<m''>, C<s'''>, C<tr///>, C<y///>
|
---|
1763 |
|
---|
1764 | No interpolation is performed.
|
---|
1765 |
|
---|
1766 | =item C<''>, C<q//>
|
---|
1767 |
|
---|
1768 | The only interpolation is removal of C<\> from pairs C<\\>.
|
---|
1769 |
|
---|
1770 | =item C<"">, C<``>, C<qq//>, C<qx//>, C<< <file*glob> >>
|
---|
1771 |
|
---|
1772 | C<\Q>, C<\U>, C<\u>, C<\L>, C<\l> (possibly paired with C<\E>) are
|
---|
1773 | converted to corresponding Perl constructs. Thus, C<"$foo\Qbaz$bar">
|
---|
1774 | is converted to C<$foo . (quotemeta("baz" . $bar))> internally.
|
---|
1775 | The other combinations are replaced with appropriate expansions.
|
---|
1776 |
|
---|
1777 | Let it be stressed that I<whatever falls between C<\Q> and C<\E>>
|
---|
1778 | is interpolated in the usual way. Something like C<"\Q\\E"> has
|
---|
1779 | no C<\E> inside. instead, it has C<\Q>, C<\\>, and C<E>, so the
|
---|
1780 | result is the same as for C<"\\\\E">. As a general rule, backslashes
|
---|
1781 | between C<\Q> and C<\E> may lead to counterintuitive results. So,
|
---|
1782 | C<"\Q\t\E"> is converted to C<quotemeta("\t")>, which is the same
|
---|
1783 | as C<"\\\t"> (since TAB is not alphanumeric). Note also that:
|
---|
1784 |
|
---|
1785 | $str = '\t';
|
---|
1786 | return "\Q$str";
|
---|
1787 |
|
---|
1788 | may be closer to the conjectural I<intention> of the writer of C<"\Q\t\E">.
|
---|
1789 |
|
---|
1790 | Interpolated scalars and arrays are converted internally to the C<join> and
|
---|
1791 | C<.> catenation operations. Thus, C<"$foo XXX '@arr'"> becomes:
|
---|
1792 |
|
---|
1793 | $foo . " XXX '" . (join $", @arr) . "'";
|
---|
1794 |
|
---|
1795 | All operations above are performed simultaneously, left to right.
|
---|
1796 |
|
---|
1797 | Because the result of C<"\Q STRING \E"> has all metacharacters
|
---|
1798 | quoted, there is no way to insert a literal C<$> or C<@> inside a
|
---|
1799 | C<\Q\E> pair. If protected by C<\>, C<$> will be quoted to became
|
---|
1800 | C<"\\\$">; if not, it is interpreted as the start of an interpolated
|
---|
1801 | scalar.
|
---|
1802 |
|
---|
1803 | Note also that the interpolation code needs to make a decision on
|
---|
1804 | where the interpolated scalar ends. For instance, whether
|
---|
1805 | C<< "a $b -> {c}" >> really means:
|
---|
1806 |
|
---|
1807 | "a " . $b . " -> {c}";
|
---|
1808 |
|
---|
1809 | or:
|
---|
1810 |
|
---|
1811 | "a " . $b -> {c};
|
---|
1812 |
|
---|
1813 | Most of the time, the longest possible text that does not include
|
---|
1814 | spaces between components and which contains matching braces or
|
---|
1815 | brackets. because the outcome may be determined by voting based
|
---|
1816 | on heuristic estimators, the result is not strictly predictable.
|
---|
1817 | Fortunately, it's usually correct for ambiguous cases.
|
---|
1818 |
|
---|
1819 | =item C<?RE?>, C</RE/>, C<m/RE/>, C<s/RE/foo/>,
|
---|
1820 |
|
---|
1821 | Processing of C<\Q>, C<\U>, C<\u>, C<\L>, C<\l>, and interpolation
|
---|
1822 | happens (almost) as with C<qq//> constructs, but the substitution
|
---|
1823 | of C<\> followed by RE-special chars (including C<\>) is not
|
---|
1824 | performed. Moreover, inside C<(?{BLOCK})>, C<(?# comment )>, and
|
---|
1825 | a C<#>-comment in a C<//x>-regular expression, no processing is
|
---|
1826 | performed whatsoever. This is the first step at which the presence
|
---|
1827 | of the C<//x> modifier is relevant.
|
---|
1828 |
|
---|
1829 | Interpolation has several quirks: C<$|>, C<$(>, and C<$)> are not
|
---|
1830 | interpolated, and constructs C<$var[SOMETHING]> are voted (by several
|
---|
1831 | different estimators) to be either an array element or C<$var>
|
---|
1832 | followed by an RE alternative. This is where the notation
|
---|
1833 | C<${arr[$bar]}> comes handy: C</${arr[0-9]}/> is interpreted as
|
---|
1834 | array element C<-9>, not as a regular expression from the variable
|
---|
1835 | C<$arr> followed by a digit, which would be the interpretation of
|
---|
1836 | C</$arr[0-9]/>. Since voting among different estimators may occur,
|
---|
1837 | the result is not predictable.
|
---|
1838 |
|
---|
1839 | It is at this step that C<\1> is begrudgingly converted to C<$1> in
|
---|
1840 | the replacement text of C<s///> to correct the incorrigible
|
---|
1841 | I<sed> hackers who haven't picked up the saner idiom yet. A warning
|
---|
1842 | is emitted if the C<use warnings> pragma or the B<-w> command-line flag
|
---|
1843 | (that is, the C<$^W> variable) was set.
|
---|
1844 |
|
---|
1845 | The lack of processing of C<\\> creates specific restrictions on
|
---|
1846 | the post-processed text. If the delimiter is C</>, one cannot get
|
---|
1847 | the combination C<\/> into the result of this step. C</> will
|
---|
1848 | finish the regular expression, C<\/> will be stripped to C</> on
|
---|
1849 | the previous step, and C<\\/> will be left as is. Because C</> is
|
---|
1850 | equivalent to C<\/> inside a regular expression, this does not
|
---|
1851 | matter unless the delimiter happens to be character special to the
|
---|
1852 | RE engine, such as in C<s*foo*bar*>, C<m[foo]>, or C<?foo?>; or an
|
---|
1853 | alphanumeric char, as in:
|
---|
1854 |
|
---|
1855 | m m ^ a \s* b mmx;
|
---|
1856 |
|
---|
1857 | In the RE above, which is intentionally obfuscated for illustration, the
|
---|
1858 | delimiter is C<m>, the modifier is C<mx>, and after backslash-removal the
|
---|
1859 | RE is the same as for C<m/ ^ a \s* b /mx>. There's more than one
|
---|
1860 | reason you're encouraged to restrict your delimiters to non-alphanumeric,
|
---|
1861 | non-whitespace choices.
|
---|
1862 |
|
---|
1863 | =back
|
---|
1864 |
|
---|
1865 | This step is the last one for all constructs except regular expressions,
|
---|
1866 | which are processed further.
|
---|
1867 |
|
---|
1868 | =item Interpolation of regular expressions
|
---|
1869 | X<regexp, interpolation>
|
---|
1870 |
|
---|
1871 | Previous steps were performed during the compilation of Perl code,
|
---|
1872 | but this one happens at run time--although it may be optimized to
|
---|
1873 | be calculated at compile time if appropriate. After preprocessing
|
---|
1874 | described above, and possibly after evaluation if catenation,
|
---|
1875 | joining, casing translation, or metaquoting are involved, the
|
---|
1876 | resulting I<string> is passed to the RE engine for compilation.
|
---|
1877 |
|
---|
1878 | Whatever happens in the RE engine might be better discussed in L<perlre>,
|
---|
1879 | but for the sake of continuity, we shall do so here.
|
---|
1880 |
|
---|
1881 | This is another step where the presence of the C<//x> modifier is
|
---|
1882 | relevant. The RE engine scans the string from left to right and
|
---|
1883 | converts it to a finite automaton.
|
---|
1884 |
|
---|
1885 | Backslashed characters are either replaced with corresponding
|
---|
1886 | literal strings (as with C<\{>), or else they generate special nodes
|
---|
1887 | in the finite automaton (as with C<\b>). Characters special to the
|
---|
1888 | RE engine (such as C<|>) generate corresponding nodes or groups of
|
---|
1889 | nodes. C<(?#...)> comments are ignored. All the rest is either
|
---|
1890 | converted to literal strings to match, or else is ignored (as is
|
---|
1891 | whitespace and C<#>-style comments if C<//x> is present).
|
---|
1892 |
|
---|
1893 | Parsing of the bracketed character class construct, C<[...]>, is
|
---|
1894 | rather different than the rule used for the rest of the pattern.
|
---|
1895 | The terminator of this construct is found using the same rules as
|
---|
1896 | for finding the terminator of a C<{}>-delimited construct, the only
|
---|
1897 | exception being that C<]> immediately following C<[> is treated as
|
---|
1898 | though preceded by a backslash. Similarly, the terminator of
|
---|
1899 | C<(?{...})> is found using the same rules as for finding the
|
---|
1900 | terminator of a C<{}>-delimited construct.
|
---|
1901 |
|
---|
1902 | It is possible to inspect both the string given to RE engine and the
|
---|
1903 | resulting finite automaton. See the arguments C<debug>/C<debugcolor>
|
---|
1904 | in the C<use L<re>> pragma, as well as Perl's B<-Dr> command-line
|
---|
1905 | switch documented in L<perlrun/"Command Switches">.
|
---|
1906 |
|
---|
1907 | =item Optimization of regular expressions
|
---|
1908 | X<regexp, optimization>
|
---|
1909 |
|
---|
1910 | This step is listed for completeness only. Since it does not change
|
---|
1911 | semantics, details of this step are not documented and are subject
|
---|
1912 | to change without notice. This step is performed over the finite
|
---|
1913 | automaton that was generated during the previous pass.
|
---|
1914 |
|
---|
1915 | It is at this stage that C<split()> silently optimizes C</^/> to
|
---|
1916 | mean C</^/m>.
|
---|
1917 |
|
---|
1918 | =back
|
---|
1919 |
|
---|
1920 | =head2 I/O Operators
|
---|
1921 | X<operator, i/o> X<operator, io> X<io> X<while> X<filehandle>
|
---|
1922 | X<< <> >> X<@ARGV>
|
---|
1923 |
|
---|
1924 | There are several I/O operators you should know about.
|
---|
1925 |
|
---|
1926 | A string enclosed by backticks (grave accents) first undergoes
|
---|
1927 | double-quote interpolation. It is then interpreted as an external
|
---|
1928 | command, and the output of that command is the value of the
|
---|
1929 | backtick string, like in a shell. In scalar context, a single string
|
---|
1930 | consisting of all output is returned. In list context, a list of
|
---|
1931 | values is returned, one per line of output. (You can set C<$/> to use
|
---|
1932 | a different line terminator.) The command is executed each time the
|
---|
1933 | pseudo-literal is evaluated. The status value of the command is
|
---|
1934 | returned in C<$?> (see L<perlvar> for the interpretation of C<$?>).
|
---|
1935 | Unlike in B<csh>, no translation is done on the return data--newlines
|
---|
1936 | remain newlines. Unlike in any of the shells, single quotes do not
|
---|
1937 | hide variable names in the command from interpretation. To pass a
|
---|
1938 | literal dollar-sign through to the shell you need to hide it with a
|
---|
1939 | backslash. The generalized form of backticks is C<qx//>. (Because
|
---|
1940 | backticks always undergo shell expansion as well, see L<perlsec> for
|
---|
1941 | security concerns.)
|
---|
1942 | X<qx> X<`> X<``> X<backtick> X<glob>
|
---|
1943 |
|
---|
1944 | In scalar context, evaluating a filehandle in angle brackets yields
|
---|
1945 | the next line from that file (the newline, if any, included), or
|
---|
1946 | C<undef> at end-of-file or on error. When C<$/> is set to C<undef>
|
---|
1947 | (sometimes known as file-slurp mode) and the file is empty, it
|
---|
1948 | returns C<''> the first time, followed by C<undef> subsequently.
|
---|
1949 |
|
---|
1950 | Ordinarily you must assign the returned value to a variable, but
|
---|
1951 | there is one situation where an automatic assignment happens. If
|
---|
1952 | and only if the input symbol is the only thing inside the conditional
|
---|
1953 | of a C<while> statement (even if disguised as a C<for(;;)> loop),
|
---|
1954 | the value is automatically assigned to the global variable $_,
|
---|
1955 | destroying whatever was there previously. (This may seem like an
|
---|
1956 | odd thing to you, but you'll use the construct in almost every Perl
|
---|
1957 | script you write.) The $_ variable is not implicitly localized.
|
---|
1958 | You'll have to put a C<local $_;> before the loop if you want that
|
---|
1959 | to happen.
|
---|
1960 |
|
---|
1961 | The following lines are equivalent:
|
---|
1962 |
|
---|
1963 | while (defined($_ = <STDIN>)) { print; }
|
---|
1964 | while ($_ = <STDIN>) { print; }
|
---|
1965 | while (<STDIN>) { print; }
|
---|
1966 | for (;<STDIN>;) { print; }
|
---|
1967 | print while defined($_ = <STDIN>);
|
---|
1968 | print while ($_ = <STDIN>);
|
---|
1969 | print while <STDIN>;
|
---|
1970 |
|
---|
1971 | This also behaves similarly, but avoids $_ :
|
---|
1972 |
|
---|
1973 | while (my $line = <STDIN>) { print $line }
|
---|
1974 |
|
---|
1975 | In these loop constructs, the assigned value (whether assignment
|
---|
1976 | is automatic or explicit) is then tested to see whether it is
|
---|
1977 | defined. The defined test avoids problems where line has a string
|
---|
1978 | value that would be treated as false by Perl, for example a "" or
|
---|
1979 | a "0" with no trailing newline. If you really mean for such values
|
---|
1980 | to terminate the loop, they should be tested for explicitly:
|
---|
1981 |
|
---|
1982 | while (($_ = <STDIN>) ne '0') { ... }
|
---|
1983 | while (<STDIN>) { last unless $_; ... }
|
---|
1984 |
|
---|
1985 | In other boolean contexts, C<< <I<filehandle>> >> without an
|
---|
1986 | explicit C<defined> test or comparison elicit a warning if the
|
---|
1987 | C<use warnings> pragma or the B<-w>
|
---|
1988 | command-line switch (the C<$^W> variable) is in effect.
|
---|
1989 |
|
---|
1990 | The filehandles STDIN, STDOUT, and STDERR are predefined. (The
|
---|
1991 | filehandles C<stdin>, C<stdout>, and C<stderr> will also work except
|
---|
1992 | in packages, where they would be interpreted as local identifiers
|
---|
1993 | rather than global.) Additional filehandles may be created with
|
---|
1994 | the open() function, amongst others. See L<perlopentut> and
|
---|
1995 | L<perlfunc/open> for details on this.
|
---|
1996 | X<stdin> X<stdout> X<sterr>
|
---|
1997 |
|
---|
1998 | If a <FILEHANDLE> is used in a context that is looking for
|
---|
1999 | a list, a list comprising all input lines is returned, one line per
|
---|
2000 | list element. It's easy to grow to a rather large data space this
|
---|
2001 | way, so use with care.
|
---|
2002 |
|
---|
2003 | <FILEHANDLE> may also be spelled C<readline(*FILEHANDLE)>.
|
---|
2004 | See L<perlfunc/readline>.
|
---|
2005 |
|
---|
2006 | The null filehandle <> is special: it can be used to emulate the
|
---|
2007 | behavior of B<sed> and B<awk>. Input from <> comes either from
|
---|
2008 | standard input, or from each file listed on the command line. Here's
|
---|
2009 | how it works: the first time <> is evaluated, the @ARGV array is
|
---|
2010 | checked, and if it is empty, C<$ARGV[0]> is set to "-", which when opened
|
---|
2011 | gives you standard input. The @ARGV array is then processed as a list
|
---|
2012 | of filenames. The loop
|
---|
2013 |
|
---|
2014 | while (<>) {
|
---|
2015 | ... # code for each line
|
---|
2016 | }
|
---|
2017 |
|
---|
2018 | is equivalent to the following Perl-like pseudo code:
|
---|
2019 |
|
---|
2020 | unshift(@ARGV, '-') unless @ARGV;
|
---|
2021 | while ($ARGV = shift) {
|
---|
2022 | open(ARGV, $ARGV);
|
---|
2023 | while (<ARGV>) {
|
---|
2024 | ... # code for each line
|
---|
2025 | }
|
---|
2026 | }
|
---|
2027 |
|
---|
2028 | except that it isn't so cumbersome to say, and will actually work.
|
---|
2029 | It really does shift the @ARGV array and put the current filename
|
---|
2030 | into the $ARGV variable. It also uses filehandle I<ARGV>
|
---|
2031 | internally--<> is just a synonym for <ARGV>, which
|
---|
2032 | is magical. (The pseudo code above doesn't work because it treats
|
---|
2033 | <ARGV> as non-magical.)
|
---|
2034 |
|
---|
2035 | You can modify @ARGV before the first <> as long as the array ends up
|
---|
2036 | containing the list of filenames you really want. Line numbers (C<$.>)
|
---|
2037 | continue as though the input were one big happy file. See the example
|
---|
2038 | in L<perlfunc/eof> for how to reset line numbers on each file.
|
---|
2039 |
|
---|
2040 | If you want to set @ARGV to your own list of files, go right ahead.
|
---|
2041 | This sets @ARGV to all plain text files if no @ARGV was given:
|
---|
2042 |
|
---|
2043 | @ARGV = grep { -f && -T } glob('*') unless @ARGV;
|
---|
2044 |
|
---|
2045 | You can even set them to pipe commands. For example, this automatically
|
---|
2046 | filters compressed arguments through B<gzip>:
|
---|
2047 |
|
---|
2048 | @ARGV = map { /\.(gz|Z)$/ ? "gzip -dc < $_ |" : $_ } @ARGV;
|
---|
2049 |
|
---|
2050 | If you want to pass switches into your script, you can use one of the
|
---|
2051 | Getopts modules or put a loop on the front like this:
|
---|
2052 |
|
---|
2053 | while ($_ = $ARGV[0], /^-/) {
|
---|
2054 | shift;
|
---|
2055 | last if /^--$/;
|
---|
2056 | if (/^-D(.*)/) { $debug = $1 }
|
---|
2057 | if (/^-v/) { $verbose++ }
|
---|
2058 | # ... # other switches
|
---|
2059 | }
|
---|
2060 |
|
---|
2061 | while (<>) {
|
---|
2062 | # ... # code for each line
|
---|
2063 | }
|
---|
2064 |
|
---|
2065 | The <> symbol will return C<undef> for end-of-file only once.
|
---|
2066 | If you call it again after this, it will assume you are processing another
|
---|
2067 | @ARGV list, and if you haven't set @ARGV, will read input from STDIN.
|
---|
2068 |
|
---|
2069 | If what the angle brackets contain is a simple scalar variable (e.g.,
|
---|
2070 | <$foo>), then that variable contains the name of the
|
---|
2071 | filehandle to input from, or its typeglob, or a reference to the
|
---|
2072 | same. For example:
|
---|
2073 |
|
---|
2074 | $fh = \*STDIN;
|
---|
2075 | $line = <$fh>;
|
---|
2076 |
|
---|
2077 | If what's within the angle brackets is neither a filehandle nor a simple
|
---|
2078 | scalar variable containing a filehandle name, typeglob, or typeglob
|
---|
2079 | reference, it is interpreted as a filename pattern to be globbed, and
|
---|
2080 | either a list of filenames or the next filename in the list is returned,
|
---|
2081 | depending on context. This distinction is determined on syntactic
|
---|
2082 | grounds alone. That means C<< <$x> >> is always a readline() from
|
---|
2083 | an indirect handle, but C<< <$hash{key}> >> is always a glob().
|
---|
2084 | That's because $x is a simple scalar variable, but C<$hash{key}> is
|
---|
2085 | not--it's a hash element. Even C<< <$x > >> (note the extra space)
|
---|
2086 | is treated as C<glob("$x ")>, not C<readline($x)>.
|
---|
2087 |
|
---|
2088 | One level of double-quote interpretation is done first, but you can't
|
---|
2089 | say C<< <$foo> >> because that's an indirect filehandle as explained
|
---|
2090 | in the previous paragraph. (In older versions of Perl, programmers
|
---|
2091 | would insert curly brackets to force interpretation as a filename glob:
|
---|
2092 | C<< <${foo}> >>. These days, it's considered cleaner to call the
|
---|
2093 | internal function directly as C<glob($foo)>, which is probably the right
|
---|
2094 | way to have done it in the first place.) For example:
|
---|
2095 |
|
---|
2096 | while (<*.c>) {
|
---|
2097 | chmod 0644, $_;
|
---|
2098 | }
|
---|
2099 |
|
---|
2100 | is roughly equivalent to:
|
---|
2101 |
|
---|
2102 | open(FOO, "echo *.c | tr -s ' \t\r\f' '\\012\\012\\012\\012'|");
|
---|
2103 | while (<FOO>) {
|
---|
2104 | chomp;
|
---|
2105 | chmod 0644, $_;
|
---|
2106 | }
|
---|
2107 |
|
---|
2108 | except that the globbing is actually done internally using the standard
|
---|
2109 | C<File::Glob> extension. Of course, the shortest way to do the above is:
|
---|
2110 |
|
---|
2111 | chmod 0644, <*.c>;
|
---|
2112 |
|
---|
2113 | A (file)glob evaluates its (embedded) argument only when it is
|
---|
2114 | starting a new list. All values must be read before it will start
|
---|
2115 | over. In list context, this isn't important because you automatically
|
---|
2116 | get them all anyway. However, in scalar context the operator returns
|
---|
2117 | the next value each time it's called, or C<undef> when the list has
|
---|
2118 | run out. As with filehandle reads, an automatic C<defined> is
|
---|
2119 | generated when the glob occurs in the test part of a C<while>,
|
---|
2120 | because legal glob returns (e.g. a file called F<0>) would otherwise
|
---|
2121 | terminate the loop. Again, C<undef> is returned only once. So if
|
---|
2122 | you're expecting a single value from a glob, it is much better to
|
---|
2123 | say
|
---|
2124 |
|
---|
2125 | ($file) = <blurch*>;
|
---|
2126 |
|
---|
2127 | than
|
---|
2128 |
|
---|
2129 | $file = <blurch*>;
|
---|
2130 |
|
---|
2131 | because the latter will alternate between returning a filename and
|
---|
2132 | returning false.
|
---|
2133 |
|
---|
2134 | If you're trying to do variable interpolation, it's definitely better
|
---|
2135 | to use the glob() function, because the older notation can cause people
|
---|
2136 | to become confused with the indirect filehandle notation.
|
---|
2137 |
|
---|
2138 | @files = glob("$dir/*.[ch]");
|
---|
2139 | @files = glob($files[$i]);
|
---|
2140 |
|
---|
2141 | =head2 Constant Folding
|
---|
2142 | X<constant folding> X<folding>
|
---|
2143 |
|
---|
2144 | Like C, Perl does a certain amount of expression evaluation at
|
---|
2145 | compile time whenever it determines that all arguments to an
|
---|
2146 | operator are static and have no side effects. In particular, string
|
---|
2147 | concatenation happens at compile time between literals that don't do
|
---|
2148 | variable substitution. Backslash interpolation also happens at
|
---|
2149 | compile time. You can say
|
---|
2150 |
|
---|
2151 | 'Now is the time for all' . "\n" .
|
---|
2152 | 'good men to come to.'
|
---|
2153 |
|
---|
2154 | and this all reduces to one string internally. Likewise, if
|
---|
2155 | you say
|
---|
2156 |
|
---|
2157 | foreach $file (@filenames) {
|
---|
2158 | if (-s $file > 5 + 100 * 2**16) { }
|
---|
2159 | }
|
---|
2160 |
|
---|
2161 | the compiler will precompute the number which that expression
|
---|
2162 | represents so that the interpreter won't have to.
|
---|
2163 |
|
---|
2164 | =head2 No-ops
|
---|
2165 | X<no-op> X<nop>
|
---|
2166 |
|
---|
2167 | Perl doesn't officially have a no-op operator, but the bare constants
|
---|
2168 | C<0> and C<1> are special-cased to not produce a warning in a void
|
---|
2169 | context, so you can for example safely do
|
---|
2170 |
|
---|
2171 | 1 while foo();
|
---|
2172 |
|
---|
2173 | =head2 Bitwise String Operators
|
---|
2174 | X<operator, bitwise, string>
|
---|
2175 |
|
---|
2176 | Bitstrings of any size may be manipulated by the bitwise operators
|
---|
2177 | (C<~ | & ^>).
|
---|
2178 |
|
---|
2179 | If the operands to a binary bitwise op are strings of different
|
---|
2180 | sizes, B<|> and B<^> ops act as though the shorter operand had
|
---|
2181 | additional zero bits on the right, while the B<&> op acts as though
|
---|
2182 | the longer operand were truncated to the length of the shorter.
|
---|
2183 | The granularity for such extension or truncation is one or more
|
---|
2184 | bytes.
|
---|
2185 |
|
---|
2186 | # ASCII-based examples
|
---|
2187 | print "j p \n" ^ " a h"; # prints "JAPH\n"
|
---|
2188 | print "JA" | " ph\n"; # prints "japh\n"
|
---|
2189 | print "japh\nJunk" & '_____'; # prints "JAPH\n";
|
---|
2190 | print 'p N$' ^ " E<H\n"; # prints "Perl\n";
|
---|
2191 |
|
---|
2192 | If you are intending to manipulate bitstrings, be certain that
|
---|
2193 | you're supplying bitstrings: If an operand is a number, that will imply
|
---|
2194 | a B<numeric> bitwise operation. You may explicitly show which type of
|
---|
2195 | operation you intend by using C<""> or C<0+>, as in the examples below.
|
---|
2196 |
|
---|
2197 | $foo = 150 | 105; # yields 255 (0x96 | 0x69 is 0xFF)
|
---|
2198 | $foo = '150' | 105; # yields 255
|
---|
2199 | $foo = 150 | '105'; # yields 255
|
---|
2200 | $foo = '150' | '105'; # yields string '155' (under ASCII)
|
---|
2201 |
|
---|
2202 | $baz = 0+$foo & 0+$bar; # both ops explicitly numeric
|
---|
2203 | $biz = "$foo" ^ "$bar"; # both ops explicitly stringy
|
---|
2204 |
|
---|
2205 | See L<perlfunc/vec> for information on how to manipulate individual bits
|
---|
2206 | in a bit vector.
|
---|
2207 |
|
---|
2208 | =head2 Integer Arithmetic
|
---|
2209 | X<integer>
|
---|
2210 |
|
---|
2211 | By default, Perl assumes that it must do most of its arithmetic in
|
---|
2212 | floating point. But by saying
|
---|
2213 |
|
---|
2214 | use integer;
|
---|
2215 |
|
---|
2216 | you may tell the compiler that it's okay to use integer operations
|
---|
2217 | (if it feels like it) from here to the end of the enclosing BLOCK.
|
---|
2218 | An inner BLOCK may countermand this by saying
|
---|
2219 |
|
---|
2220 | no integer;
|
---|
2221 |
|
---|
2222 | which lasts until the end of that BLOCK. Note that this doesn't
|
---|
2223 | mean everything is only an integer, merely that Perl may use integer
|
---|
2224 | operations if it is so inclined. For example, even under C<use
|
---|
2225 | integer>, if you take the C<sqrt(2)>, you'll still get C<1.4142135623731>
|
---|
2226 | or so.
|
---|
2227 |
|
---|
2228 | Used on numbers, the bitwise operators ("&", "|", "^", "~", "<<",
|
---|
2229 | and ">>") always produce integral results. (But see also
|
---|
2230 | L<Bitwise String Operators>.) However, C<use integer> still has meaning for
|
---|
2231 | them. By default, their results are interpreted as unsigned integers, but
|
---|
2232 | if C<use integer> is in effect, their results are interpreted
|
---|
2233 | as signed integers. For example, C<~0> usually evaluates to a large
|
---|
2234 | integral value. However, C<use integer; ~0> is C<-1> on twos-complement
|
---|
2235 | machines.
|
---|
2236 |
|
---|
2237 | =head2 Floating-point Arithmetic
|
---|
2238 | X<floating-point> X<floating point> X<float> X<real>
|
---|
2239 |
|
---|
2240 | While C<use integer> provides integer-only arithmetic, there is no
|
---|
2241 | analogous mechanism to provide automatic rounding or truncation to a
|
---|
2242 | certain number of decimal places. For rounding to a certain number
|
---|
2243 | of digits, sprintf() or printf() is usually the easiest route.
|
---|
2244 | See L<perlfaq4>.
|
---|
2245 |
|
---|
2246 | Floating-point numbers are only approximations to what a mathematician
|
---|
2247 | would call real numbers. There are infinitely more reals than floats,
|
---|
2248 | so some corners must be cut. For example:
|
---|
2249 |
|
---|
2250 | printf "%.20g\n", 123456789123456789;
|
---|
2251 | # produces 123456789123456784
|
---|
2252 |
|
---|
2253 | Testing for exact equality of floating-point equality or inequality is
|
---|
2254 | not a good idea. Here's a (relatively expensive) work-around to compare
|
---|
2255 | whether two floating-point numbers are equal to a particular number of
|
---|
2256 | decimal places. See Knuth, volume II, for a more robust treatment of
|
---|
2257 | this topic.
|
---|
2258 |
|
---|
2259 | sub fp_equal {
|
---|
2260 | my ($X, $Y, $POINTS) = @_;
|
---|
2261 | my ($tX, $tY);
|
---|
2262 | $tX = sprintf("%.${POINTS}g", $X);
|
---|
2263 | $tY = sprintf("%.${POINTS}g", $Y);
|
---|
2264 | return $tX eq $tY;
|
---|
2265 | }
|
---|
2266 |
|
---|
2267 | The POSIX module (part of the standard perl distribution) implements
|
---|
2268 | ceil(), floor(), and other mathematical and trigonometric functions.
|
---|
2269 | The Math::Complex module (part of the standard perl distribution)
|
---|
2270 | defines mathematical functions that work on both the reals and the
|
---|
2271 | imaginary numbers. Math::Complex not as efficient as POSIX, but
|
---|
2272 | POSIX can't work with complex numbers.
|
---|
2273 |
|
---|
2274 | Rounding in financial applications can have serious implications, and
|
---|
2275 | the rounding method used should be specified precisely. In these
|
---|
2276 | cases, it probably pays not to trust whichever system rounding is
|
---|
2277 | being used by Perl, but to instead implement the rounding function you
|
---|
2278 | need yourself.
|
---|
2279 |
|
---|
2280 | =head2 Bigger Numbers
|
---|
2281 | X<number, arbitrary precision>
|
---|
2282 |
|
---|
2283 | The standard Math::BigInt and Math::BigFloat modules provide
|
---|
2284 | variable-precision arithmetic and overloaded operators, although
|
---|
2285 | they're currently pretty slow. At the cost of some space and
|
---|
2286 | considerable speed, they avoid the normal pitfalls associated with
|
---|
2287 | limited-precision representations.
|
---|
2288 |
|
---|
2289 | use Math::BigInt;
|
---|
2290 | $x = Math::BigInt->new('123456789123456789');
|
---|
2291 | print $x * $x;
|
---|
2292 |
|
---|
2293 | # prints +15241578780673678515622620750190521
|
---|
2294 |
|
---|
2295 | There are several modules that let you calculate with (bound only by
|
---|
2296 | memory and cpu-time) unlimited or fixed precision. There are also
|
---|
2297 | some non-standard modules that provide faster implementations via
|
---|
2298 | external C libraries.
|
---|
2299 |
|
---|
2300 | Here is a short, but incomplete summary:
|
---|
2301 |
|
---|
2302 | Math::Fraction big, unlimited fractions like 9973 / 12967
|
---|
2303 | Math::String treat string sequences like numbers
|
---|
2304 | Math::FixedPrecision calculate with a fixed precision
|
---|
2305 | Math::Currency for currency calculations
|
---|
2306 | Bit::Vector manipulate bit vectors fast (uses C)
|
---|
2307 | Math::BigIntFast Bit::Vector wrapper for big numbers
|
---|
2308 | Math::Pari provides access to the Pari C library
|
---|
2309 | Math::BigInteger uses an external C library
|
---|
2310 | Math::Cephes uses external Cephes C library (no big numbers)
|
---|
2311 | Math::Cephes::Fraction fractions via the Cephes library
|
---|
2312 | Math::GMP another one using an external C library
|
---|
2313 |
|
---|
2314 | Choose wisely.
|
---|
2315 |
|
---|
2316 | =cut
|
---|