X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=pod%2Fperlop.pod;h=d9dc77fc620605a97f47529ae7195b1bf9f7e0c4;hb=7a1c739b67fd7d50a3ebda573fb9722f1a02a122;hp=1550660df67785f127b347d07a7123940127ff97;hpb=fb53bbb20d623d0dbe701aa5d8875b725debcd99;p=p5sagit%2Fp5-mst-13.2.git diff --git a/pod/perlop.pod b/pod/perlop.pod index 1550660..d9dc77f 100644 --- a/pod/perlop.pod +++ b/pod/perlop.pod @@ -1,8 +1,27 @@ =head1 NAME +X perlop - Perl operators and precedence -=head1 SYNOPSIS +=head1 DESCRIPTION + +=head2 Operator Precedence and Associativity +X X X + +Operator precedence and associativity work in Perl more or less like +they do in mathematics. + +I means some operators are evaluated before +others. For example, in C<2 + 4 * 5>, the multiplication has higher +precedence so C<4 * 5> is evaluated first yielding C<2 + 20 == +22> and not C<6 * 5 == 30>. + +I defines what happens if a sequence of the +same operators is used one after another: whether the evaluator will +evaluate the left operations first or the right. For example, in C<8 +- 4 - 2>, subtraction is left associative so Perl evaluates the +expression left to right. C<8 - 4> is evaluated first making the +expression C<4 - 2 == 2> and not C<8 - 2 == 6>. Perl operators have the following associativity and precedence, listed from highest precedence to lowest. Operators borrowed from @@ -22,7 +41,7 @@ values only, not array values. left << >> nonassoc named unary operators nonassoc < > <= >= lt gt le ge - nonassoc == != <=> eq ne cmp + nonassoc == != <=> eq ne cmp ~~ left & left | ^ left && @@ -40,9 +59,8 @@ In the following sections, these operators are covered in precedence order. Many operators can be overloaded for objects. See L. -=head1 DESCRIPTION - =head2 Terms and List Operators (Leftward) +X X X A TERM has the highest precedence in Perl. They include variables, quote and quote-like operators, any expression in parentheses, @@ -83,8 +101,18 @@ Also note that print ($foo & 255) + 1, "\n"; -probably doesn't do what you expect at first glance. See -L for more discussion of this. +probably doesn't do what you expect at first glance. The parentheses +enclose the argument list for C which is evaluated (printing +the result of C<$foo & 255>). Then one is added to the return value +of C (usually 1). The result is something like this: + + 1 + 1, "\n"; # Obviously not what you meant. + +To do what you meant properly, you must write: + + print(($foo & 255) + 1, "\n"); + +See L for more discussion of this. Also parsed as terms are the C and C constructs, as well as subroutine and method calls, and the anonymous @@ -94,6 +122,7 @@ See also L toward the end of this section, as well as L<"I/O Operators">. =head2 The Arrow Operator +X X X<< -> >> "C<< -> >>" is an infix dereference operator, just as it is in C and C++. If the right side is either a C<[...]>, C<{...}>, or a @@ -109,10 +138,27 @@ and the left side must be either an object (a blessed reference) or a class name (that is, a package name). See L. =head2 Auto-increment and Auto-decrement +X X X<++> X X X<--> + +"++" and "--" work as in C. That is, if placed before a variable, +they increment or decrement the variable by one before returning the +value, and if placed after, increment or decrement after returning the +value. + + $i = 0; $j = 0; + print $i++; # prints 0 + print ++$j; # prints 1 + +Note that just as in C, Perl doesn't define B the variable is +incremented or decremented. You just know it will be done sometime +before or after the value is returned. This also means that modifying +a variable twice in the same statement will lead to undefined behaviour. +Avoid statements like: + + $i = $i ++; + print ++ $i + $i ++; -"++" and "--" work as in C. That is, if placed before a variable, they -increment or decrement the variable before returning the value, and if -placed after, increment or decrement the variable after returning the value. +Perl will not guarantee what the result of the above statements is. The auto-increment operator has a little extra builtin magic to it. If you increment a variable that is numeric, or that has ever been used in @@ -134,6 +180,7 @@ will return C<0> rather than C). The auto-decrement operator is not magical. =head2 Exponentiation +X<**> X X Binary "**" is the exponentiation operator. It binds even more tightly than unary minus, so -2**4 is -(2**4), not (-2)**4. (This is @@ -141,35 +188,46 @@ implemented using C's pow(3) function, which actually works on doubles internally.) =head2 Symbolic Unary Operators +X X Unary "!" performs logical negation, i.e., "not". See also C for a lower precedence version of this. +X Unary "-" performs arithmetic negation if the operand is numeric. If the operand is an identifier, a string consisting of a minus sign concatenated with the identifier is returned. Otherwise, if the string starts with a plus or minus, a string starting with the opposite sign -is returned. One effect of these rules is that C<-bareword> is equivalent -to C<"-bareword">. +is returned. One effect of these rules is that -bareword is equivalent +to the string "-bareword". If, however, the string begins with a +non-alphabetic character (exluding "+" or "-"), Perl will attempt to convert +the string to a numeric and the arithmetic negation is performed. If the +string cannot be cleanly converted to a numeric, Perl will give the warning +B. +X<-> X Unary "~" performs bitwise negation, i.e., 1's complement. For example, C<0666 & ~027> is 0640. (See also L and L.) Note that the width of the result is platform-dependent: ~0 is 32 bits wide on a 32-bit platform, but 64 bits wide on a 64-bit platform, so if you are expecting a certain bit -width, remember use the & operator to mask off the excess bits. +width, remember to use the & operator to mask off the excess bits. +X<~> X Unary "+" has no effect whatsoever, even on strings. It is useful syntactically for separating a function name from a parenthesized expression that would otherwise be interpreted as the complete list of function arguments. (See examples above under L.) +X<+> Unary "\" creates a reference to whatever follows it. See L and L. Do not confuse this behavior with the behavior of backslash within a string, although both forms do convey the notion of protecting the next thing from interpolation. +X<\> X X =head2 Binding Operators +X X X<=~> X Binary "=~" binds a scalar expression to a pattern match. Certain operations search or modify the string $_ by default. This operator makes that kind @@ -178,7 +236,8 @@ pattern, substitution, or transliteration. The left argument is what is supposed to be searched, substituted, or transliterated instead of the default $_. When used in scalar context, the return value generally indicates the success of the operation. Behavior in list context depends on the particular -operator. See L for details. +operator. See L for details and +L for examples using these operators. If the right argument is an expression rather than a search pattern, substitution, or transliteration, it is interpreted as a search pattern at run @@ -188,10 +247,13 @@ Binary "!~" is just like "=~" except the return value is negated in the logical sense. =head2 Multiplicative Operators +X Binary "*" multiplies two numbers. +X<*> Binary "/" divides two numbers. +X X Binary "%" computes the modulus of two numbers. Given integer operands C<$a> and C<$b>: If C<$b> is positive, then C<$a % $b> is @@ -203,12 +265,16 @@ Note that when C is in scope, "%" gives you direct access to the modulus operator as implemented by your C compiler. This operator is not as well defined for negative operands, but it will execute faster. +X<%> X X X Binary "x" is the repetition operator. In scalar context or if the left operand is not enclosed in parentheses, it returns a string consisting of the left operand repeated the number of times specified by the right operand. In list context, if the left operand is enclosed in -parentheses, it repeats the list. +parentheses or is a list formed by C, it repeats the list. +If the right operand is zero or negative, it returns an empty string +or an empty list, depending on the context. +X print '-' x 80; # print row of dashes @@ -219,14 +285,22 @@ parentheses, it repeats the list. =head2 Additive Operators +X Binary "+" returns the sum of two numbers. +X<+> Binary "-" returns the difference of two numbers. +X<-> Binary "." concatenates two strings. +X X +X X X X<.> =head2 Shift Operators +X X X<<< << >>> +X<<< >> >>> X X X +X X X X Binary "<<" returns the value of its left argument shifted left by the number of bits specified by the right argument. Arguments should be @@ -249,10 +323,10 @@ integers, C<< 1 << 32 >> is undefined. Shifting by a negative number of bits is also undefined. =head2 Named Unary Operators +X The various named unary operators are treated as functions with one -argument, with optional parentheses. These include the filetest -operators, like C<-f>, C<-M>, etc. See L. +argument, with optional parentheses. If any list operator (print(), etc.) or any unary operator (chdir(), etc.) is followed by a left parenthesis as the next token, the operator and @@ -277,41 +351,59 @@ but, because * is higher precedence than named operators: rand (10) * 20; # (rand 10) * 20 rand +(10) * 20; # rand (10 * 20) +Regarding precedence, the filetest operators, like C<-f>, C<-M>, etc. are +treated like named unary operators, but they don't follow this functional +parenthesis rule. That means, for example, that C<-f($file).".bak"> is +equivalent to C<-f "$file.bak">. +X<-X> X X + See also L<"Terms and List Operators (Leftward)">. =head2 Relational Operators +X X Binary "<" returns true if the left argument is numerically less than the right argument. +X<< < >> Binary ">" returns true if the left argument is numerically greater than the right argument. +X<< > >> Binary "<=" returns true if the left argument is numerically less than or equal to the right argument. +X<< <= >> Binary ">=" returns true if the left argument is numerically greater than or equal to the right argument. +X<< >= >> Binary "lt" returns true if the left argument is stringwise less than the right argument. +X<< lt >> Binary "gt" returns true if the left argument is stringwise greater than the right argument. +X<< gt >> Binary "le" returns true if the left argument is stringwise less than or equal to the right argument. +X<< le >> Binary "ge" returns true if the left argument is stringwise greater than or equal to the right argument. +X<< ge >> =head2 Equality Operators +X X X X Binary "==" returns true if the left argument is numerically equal to the right argument. +X<==> Binary "!=" returns true if the left argument is numerically not equal to the right argument. +X Binary "<=>" returns -1, 0, or 1 depending on whether the left argument is numerically less than, equal to, or greater than the right @@ -320,24 +412,35 @@ values, using them with "<=>" returns undef. NaN is not "<", "==", ">", "<=" or ">=" anything (even NaN), so those 5 return false. NaN != NaN returns true, as does NaN != anything else. If your platform doesn't support NaNs then NaN is just a string with numeric value 0. +X<< <=> >> X - perl -le '$a = NaN; print "No NaN support here" if $a == $a' - perl -le '$a = NaN; print "NaN support here" if $a != $a' + perl -le '$a = "NaN"; print "No NaN support here" if $a == $a' + perl -le '$a = "NaN"; print "NaN support here" if $a != $a' Binary "eq" returns true if the left argument is stringwise equal to the right argument. +X Binary "ne" returns true if the left argument is stringwise not equal to the right argument. +X Binary "cmp" returns -1, 0, or 1 depending on whether the left argument is stringwise less than, equal to, or greater than the right argument. +X + +Binary "~~" does a smart match between its arguments. Smart matching +is described in L. +This operator is only available if you enable the "~~" feature: +see L for more information. +X<~~> "lt", "le", "ge", "gt" and "cmp" use the collation (sort) order specified by the current locale if C is in effect. See L. =head2 Bitwise And +X X X<&> Binary "&" returns its operands ANDed together bit by bit. (See also L and L.) @@ -348,6 +451,8 @@ the brackets are essential in a test like print "Even\n" if ($x & 1) == 0; =head2 Bitwise Or and Exclusive Or +X X X<|> X +X X<^> Binary "|" returns its operands ORed together bit by bit. (See also L and L.) @@ -361,6 +466,7 @@ for example the brackets are essential in a test like print "false\n" if (8 | 2) != 10; =head2 C-style Logical And +X<&&> X X Binary "&&" performs a short-circuit logical AND operation. That is, if the left operand is false, the right operand is not even evaluated. @@ -368,6 +474,7 @@ Scalar or list context propagates down to the right operand if it is evaluated. =head2 C-style Logical Or +X<||> X Binary "||" performs a short-circuit logical OR operation. That is, if the left operand is true, the right operand is not even evaluated. @@ -375,6 +482,7 @@ Scalar or list context propagates down to the right operand if it is evaluated. =head2 C-style Logical Defined-Or +X X Although it has no direct equivalent in C, Perl's C operator is related to its C-style or. In fact, it's exactly the same as C<||>, except that it @@ -382,12 +490,12 @@ tests the left hand side's definedness instead of its truth. Thus, C<$a // $b> is similar to C (except that it returns the value of C<$a> rather than the value of C) and is exactly equivalent to C. This is very useful for providing default values -for variables. If you actually want to test if at least one of C<$a> and C<$b> is -defined, use C. +for variables. If you actually want to test if at least one of C<$a> and +C<$b> is defined, use C. -The C<||>, C and C<&&> operators differ from C's in that, rather than returning -0 or 1, they return the last value evaluated. Thus, a reasonably portable -way to find out the home directory might be: +The C<||>, C and C<&&> operators return the last value evaluated +(unlike C's C<||> and C<&&>, which return 0 or 1). Thus, a reasonably +portable way to find out the home directory might be: $home = $ENV{'HOME'} // $ENV{'LOGDIR'} // (getpwuid($<))[7] // die "You're homeless!\n"; @@ -416,6 +524,7 @@ With the C-style operators that would have been written like this: Using "or" for assignment is unlikely to do what you want; see below. =head2 Range Operators +X X X<..> X<...> Binary ".." is the range operator, which is really two different operators depending on the context. In list context, it returns a @@ -479,9 +588,12 @@ As a scalar operator: if (101 .. 200) { print; } # print 2nd hundred lines, short for # if ($. == 101 .. $. == 200) ... - next line if (1 .. /^$/); # skip header lines, short for + + next LINE if (1 .. /^$/); # skip header lines, short for # ... if ($. == 1 .. /^$/); - s/^/> / if (/^$/ .. eof()); # quote body + # (typically in a loop labeled LINE) + + s/^/> / if (/^$/ .. eof()); # quote body # parse mail messages while (<>) { @@ -496,7 +608,25 @@ As a scalar operator: close ARGV if eof; # reset $. each file } -As a list operator: +Here's a simple example to illustrate the difference between +the two range operators: + + @lines = (" - Foo", + "01 - Bar", + "1 - Baz", + " - Quux"); + + foreach (@lines) { + if (/0/ .. /1/) { + print "$_\n"; + } + } + +This program will print only the line containing "Bar". If +the range operator is changed to C<...>, it will also print the +"Baz" line. + +And now some examples as a list operator: for (101 .. 200) { print; } # print $_ 100 times @foo = @foo[0 .. $#foo]; # an expensive no-op @@ -527,6 +657,7 @@ return two elements in list context. @list = (2.18 .. 3.14); # same as @list = (2 .. 3); =head2 Conditional Operator +X X X X Ternary "?:" is the conditional operator, just as in C. It works much like an if-then-else. If the argument before the ? is true, the @@ -566,6 +697,9 @@ That should probably be written more simply as: $a += ($a % 2) ? 10 : 2; =head2 Assignment Operators +X X X<=> X<**=> X<+=> X<*=> X<&=> +X<<< <<= >>> X<&&=> X<-=> X X<|=> X<<< >>= >>> X<||=> X X<.=> +X<%=> X<^=> X "=" is the ordinary assignment operator. @@ -583,8 +717,8 @@ The following are recognized: **= += *= &= <<= &&= -= /= |= >>= ||= - .= %= ^= - x= + .= %= ^= //= + x= Although these are grouped by family, they all have the precedence of assignment. @@ -611,6 +745,7 @@ the number of elements produced by the expression on the right hand side of the assignment. =head2 Comma Operator +X X X<,> Binary "," is the comma operator. In scalar context it evaluates its left argument, throws that value away, then evaluates its right @@ -619,11 +754,34 @@ argument and returns that value. This is just like C's comma operator. In list context, it's just the list argument separator, and inserts both its arguments into the list. -The => digraph is mostly just a synonym for the comma operator. It's useful for -documenting arguments that come in pairs. As of release 5.001, it also forces -any word to the left of it to be interpreted as a string. +The C<< => >> operator is a synonym for the comma, but forces any word +(consisting entirely of word characters) to its left to be interpreted +as a string (as of 5.001). This includes words that might otherwise be +considered a constant or function call. + + use constant FOO => "something"; + + my %h = ( FOO => 23 ); + +is equivalent to: + + my %h = ("FOO", 23); + +It is I: + + my %h = ("something", 23); + +If the argument on the left is not a word, it is first interpreted as +an expression, and then the string value of that is used. + +The C<< => >> operator is helpful in documenting the correspondence +between keys and values in hashes, and other paired elements in lists. + + %hash = ( $key => $value ); + login( $username => $password ); =head2 List Operators (Rightward) +X X On the right side of a list operator, it has very low precedence, such that it controls all comma-separated expressions found there. @@ -637,11 +795,13 @@ operators without the need for extra parentheses: See also discussion of list operators in L. =head2 Logical Not +X X Unary "not" returns the logical negation of the expression to its right. It's the equivalent of "!" except for the very low precedence. =head2 Logical And +X X Binary "and" returns the logical conjunction of the two surrounding expressions. It's equivalent to && except for the very low @@ -649,6 +809,9 @@ precedence. This means that it short-circuits: i.e., the right expression is evaluated only if the left expression is true. =head2 Logical or, Defined or, and Exclusive Or +X X X +X X +X X X Binary "or" returns the logical disjunction of the two surrounding expressions. It's equivalent to || except for the very low precedence. @@ -673,15 +836,19 @@ takes higher precedence. Then again, you could always use parentheses. -Binary "err" is equivalent to C--it's just like binary "or", except it tests -its left argument's definedness instead of its truth. There are two ways to -remember "err": either because many functions return C on an Bor, -or as a sort of correction: C<$a=($b err 'default')> +Binary "err" is equivalent to C--it's just like binary "or", except it +tests its left argument's definedness instead of its truth. There are two +ways to remember "err": either because many functions return C on +an Bor, or as a sort of correction: C<$a = ($b err 'default')>. This +keyword is only available when the 'err' feature is enabled: see +L for more information. Binary "xor" returns the exclusive-OR of the two surrounding expressions. It cannot short circuit, of course. =head2 C Operators Missing From Perl +X X<&> X<*> +X X<(TYPE)> Here is what C has that Perl doesn't: @@ -703,13 +870,17 @@ Type-casting operator. =back =head2 Quote and Quote-like Operators +X X X X X X X +X X X X<'> X<''> X<"> X<""> X X<`> X<``> X<<< << >>> +X X + While we usually think of quotes as literal values, in Perl they function as operators, providing various kinds of interpolating and pattern matching capabilities. Perl provides customary quote characters for these behaviors, but also provides a way for you to choose your quote character for any of them. In the following table, a C<{}> represents -any pair of delimiters you choose. +any pair of delimiters you choose. Customary Generic Meaning Interpolates '' q{} Literal no @@ -726,11 +897,11 @@ any pair of delimiters you choose. Non-bracketing delimiters use the same character fore and aft, but the four sorts of brackets (round, angle, square, curly) will all nest, which means -that +that - q{foo{bar}baz} + q{foo{bar}baz} -is the same as +is the same as 'foo{bar}baz' @@ -753,6 +924,7 @@ from the next line. This allows you to write: The following escape sequences are available in constructs that interpolate and in transliterations. +X<\t> X<\n> X<\r> X<\f> X<\b> X<\a> X<\e> X<\x> X<\0> X<\c> X<\N> \t tab (HT, TAB) \n newline (NL) @@ -767,8 +939,12 @@ and in transliterations. \c[ control char (ESC) \N{name} named Unicode character +B: Unlike C and other languages, Perl has no \v escape sequence for +the vertical tab (VT - ASCII 11). + The following escape sequences are available in constructs that interpolate but not in transliterations. +X<\l> X<\u> X<\L> X<\U> X<\E> X<\Q> \l lowercase next char \u uppercase next char @@ -797,6 +973,8 @@ and prefer a CR+LF (C<"\015\012"> or C<"\cM\cJ">) for line terminators, and although they often accept just C<"\012">, they seldom tolerate just C<"\015">. If you get in the habit of using C<"\n"> for networking, you may be burned some day. +X X X X +X<\n> X<\r> X<\r\n> For constructs that do interpolate, variables beginning with "C<$>" or "C<@>" are interpolated. Subscripted variables such as C<$a[3]> or @@ -826,6 +1004,7 @@ within double quotes, nor do single quotes impede evaluation of variables when used within double quotes. =head2 Regexp Quote-Like Operators +X Here are the quote-like operators that apply to pattern matching and related activities. @@ -833,6 +1012,7 @@ matching and related activities. =over 8 =item ?PATTERN? +X This is just like the C search, except that it matches only once between calls to the reset() operator. This is a useful @@ -853,6 +1033,9 @@ be removed in some distant future version of Perl, perhaps somewhere around the year 2168. =item m/PATTERN/cgimosx +X X +X X X X +X X X X X X =item /PATTERN/cgimosx @@ -1034,6 +1217,7 @@ Here is the output (split into several lines): MiXeD line-noise. That's all! =item q/STRING/ +X X X<'> X<''> =item C<'STRING'> @@ -1046,6 +1230,7 @@ the delimiter or backslash is interpolated. $baz = '\n'; # a two-character string =item qq/STRING/ +X X X<"> X<""> =item "STRING" @@ -1057,6 +1242,7 @@ A double-quoted, interpolated string. $baz = "\n"; # a one-character string =item qr/STRING/imosx +X X X X X X This operator quotes (and possibly compiles) its I as a regular expression. I is interpolated the same way as I @@ -1114,6 +1300,7 @@ See L for additional information on valid syntax for STRING, and for a detailed look at the semantics of regular expressions. =item qx/STRING/ +X X<`> X<``> X =item `STRING` @@ -1147,10 +1334,10 @@ but leave its STDOUT to come out the old STDERR: $output = `cmd 3>&1 1>&2 2>&3 3>&-`; To read both a command's STDOUT and its STDERR separately, it's easiest -and safest to redirect them separately to files, and then read from those -files when the program is done: +to redirect them separately to files, and then read from those files +when the program is done: - system("program args 1>/tmp/program.stdout 2>/tmp/program.stderr"); + system("program args 1>program.stdout 2>program.stderr"); Using single-quote as a delimiter protects the command from Perl's double-quote interpolation, passing it on to the shell instead: @@ -1195,6 +1382,7 @@ Just understand what you're getting yourself into. See L<"I/O Operators"> for more discussion. =item qw/STRING/ +X X X Evaluates to a list of the words extracted out of STRING, using embedded whitespace as the word delimiters. It can be understood as being roughly @@ -1223,6 +1411,8 @@ C pragma and the B<-w> switch (that is, the C<$^W> variable) produces warnings if the STRING contains the "," or the "#" character. =item s/PATTERN/REPLACEMENT/egimosx +X X X X +X X X X X X X X Searches a string for a pattern, and if found, replaces that pattern with the replacement text and returns the number of substitutions @@ -1307,9 +1497,9 @@ Examples: \*/ # Match the closing delimiter. } []gsx; - s/^\s*(.*?)\s*$/$1/; # trim white space in $_, expensively + s/^\s*(.*?)\s*$/$1/; # trim whitespace in $_, expensively - for ($variable) { # trim white space in $variable, cheap + for ($variable) { # trim whitespace in $variable, cheap s/^\s+//; s/\s+$//; } @@ -1330,6 +1520,7 @@ to occur that you might want. Here are two common cases: 1 while s/\t+/' ' x (length($&)*8 - length($`)%8)/e; =item tr/SEARCHLIST/REPLACEMENTLIST/cds +X X X X X X =item y/SEARCHLIST/REPLACEMENTLIST/cds @@ -1419,6 +1610,7 @@ must use an eval(): eval "tr/$oldlist/$newlist/, 1" or die $@; =item < X X X<<< << >>> A line-oriented form of quoting is based on the shell "here-document" syntax. Following a C<< << >> you specify a string to terminate @@ -1513,6 +1705,7 @@ should be safe. =back =head2 Gory details of parsing quoted constructs +X When presented with something that might have several different interpretations, Perl uses the B (that's "Do What I Mean") @@ -1575,6 +1768,11 @@ Because the slash that terminated C was followed by a C, the example above is not C, but rather C with no C modifier. So the embedded C<#> is interpreted as a literal C<#>. +Also no attention is paid to C<\c\> during this search. +Thus the second C<\> in C is interpreted as a part of C<\/>, +and the following C is not recognized as a delimiter. +Instead, use C<\034> or C<\x1c> at the end of quoted constructs. + =item Removal of backslashes before delimiters During the second pass, text between the starting and ending @@ -1588,6 +1786,7 @@ Starting from this step no information about the delimiters is used in parsing. =item Interpolation +X The next step is interpolation in the text obtained, which is now delimiter-independent. There are four different cases. @@ -1701,6 +1900,7 @@ This step is the last one for all constructs except regular expressions, which are processed further. =item Interpolation of regular expressions +X Previous steps were performed during the compilation of Perl code, but this one happens at run time--although it may be optimized to @@ -1739,6 +1939,7 @@ in the C> pragma, as well as Perl's B<-Dr> command-line switch documented in L. =item Optimization of regular expressions +X This step is listed for completeness only. Since it does not change semantics, details of this step are not documented and are subject @@ -1751,6 +1952,8 @@ mean C. =back =head2 I/O Operators +X X X X X +X<< <> >> X<@ARGV> There are several I/O operators you should know about. @@ -1770,6 +1973,7 @@ literal dollar-sign through to the shell you need to hide it with a backslash. The generalized form of backticks is C. (Because backticks always undergo shell expansion as well, see L for security concerns.) +X X<`> X<``> X X In scalar context, evaluating a filehandle in angle brackets yields the next line from that file (the newline, if any, included), or @@ -1823,6 +2027,7 @@ in packages, where they would be interpreted as local identifiers rather than global.) Additional filehandles may be created with the open() function, amongst others. See L and L for details on this. +X X X If a is used in a context that is looking for a list, a list comprising all input lines is returned, one line per @@ -1911,7 +2116,8 @@ depending on context. This distinction is determined on syntactic grounds alone. That means C<< <$x> >> is always a readline() from an indirect handle, but C<< <$hash{key}> >> is always a glob(). That's because $x is a simple scalar variable, but C<$hash{key}> is -not--it's a hash element. +not--it's a hash element. Even C<< <$x > >> (note the extra space) +is treated as C, not C. One level of double-quote interpretation is done first, but you can't say C<< <$foo> >> because that's an indirect filehandle as explained @@ -1967,6 +2173,7 @@ to become confused with the indirect filehandle notation. @files = glob($files[$i]); =head2 Constant Folding +X X Like C, Perl does a certain amount of expression evaluation at compile time whenever it determines that all arguments to an @@ -1988,7 +2195,17 @@ you say the compiler will precompute the number which that expression represents so that the interpreter won't have to. +=head2 No-ops +X X + +Perl doesn't officially have a no-op operator, but the bare constants +C<0> and C<1> are special-cased to not produce a warning in a void +context, so you can for example safely do + + 1 while foo(); + =head2 Bitwise String Operators +X Bitstrings of any size may be manipulated by the bitwise operators (C<~ | & ^>). @@ -2011,8 +2228,8 @@ you're supplying bitstrings: If an operand is a number, that will imply a B bitwise operation. You may explicitly show which type of operation you intend by using C<""> or C<0+>, as in the examples below. - $foo = 150 | 105 ; # yields 255 (0x96 | 0x69 is 0xFF) - $foo = '150' | 105 ; # yields 255 + $foo = 150 | 105; # yields 255 (0x96 | 0x69 is 0xFF) + $foo = '150' | 105; # yields 255 $foo = 150 | '105'; # yields 255 $foo = '150' | '105'; # yields string '155' (under ASCII) @@ -2023,6 +2240,7 @@ See L for information on how to manipulate individual bits in a bit vector. =head2 Integer Arithmetic +X By default, Perl assumes that it must do most of its arithmetic in floating point. But by saying @@ -2051,6 +2269,7 @@ integral value. However, C is C<-1> on twos-complement machines. =head2 Floating-point Arithmetic +X X X X While C provides integer-only arithmetic, there is no analogous mechanism to provide automatic rounding or truncation to a @@ -2093,6 +2312,7 @@ being used by Perl, but to instead implement the rounding function you need yourself. =head2 Bigger Numbers +X The standard Math::BigInt and Math::BigFloat modules provide variable-precision arithmetic and overloaded operators, although