X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=pod%2Fperlop.pod;h=32a58b83a3928b853943708908d4df2a4966354a;hb=e886094b26c01a71243f931e1dd54d48122d46f1;hp=ba2ff9f73771a443e8b79e7bff59ceb543d355bd;hpb=0d594e51e853b48a97327618a6e01007b612c5cd;p=p5sagit%2Fp5-mst-13.2.git diff --git a/pod/perlop.pod b/pod/perlop.pod index ba2ff9f..32a58b8 100644 --- a/pod/perlop.pod +++ b/pod/perlop.pod @@ -1,10 +1,12 @@ =head1 NAME +X perlop - Perl operators and precedence =head1 DESCRIPTION -=head2 Operator Precedence and Associativity +=head2 Operator Precedence and Associativity +X X X Operator precedence and associativity work in Perl more or less like they do in mathematics. @@ -58,6 +60,7 @@ In the following sections, these operators are covered in precedence order. Many operators can be overloaded for objects. See L. =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, @@ -119,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 @@ -134,6 +138,7 @@ 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 @@ -175,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 @@ -182,9 +188,11 @@ 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 @@ -192,6 +200,7 @@ 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 -bareword is equivalent to the string "-bareword". +X<-> X Unary "~" performs bitwise negation, i.e., 1's complement. For example, C<0666 & ~027> is 0640. (See also L and @@ -199,18 +208,22 @@ 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 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 @@ -230,10 +243,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 @@ -245,6 +261,7 @@ 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 @@ -253,6 +270,7 @@ operand. In list context, if the left operand is enclosed in 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 @@ -263,14 +281,22 @@ or an empty list, depending on the context. =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 @@ -293,6 +319,7 @@ 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. @@ -324,42 +351,55 @@ 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 @@ -368,24 +408,29 @@ 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 "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.) @@ -396,6 +441,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.) @@ -409,6 +456,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. @@ -416,6 +464,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. @@ -423,6 +472,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 @@ -464,6 +514,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 @@ -595,6 +646,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 @@ -634,6 +686,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 "=" is the ordinary assignment operator. @@ -679,6 +734,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 @@ -714,6 +770,7 @@ between keys and values in hashes, and other paired elements in lists. 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. @@ -727,11 +784,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 @@ -739,6 +798,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. @@ -772,6 +834,8 @@ 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: @@ -793,6 +857,10 @@ 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 @@ -843,6 +911,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) @@ -862,6 +931,7 @@ 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 @@ -890,6 +960,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 @@ -919,6 +991,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. @@ -926,6 +999,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 @@ -946,6 +1020,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 @@ -1127,6 +1204,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'> @@ -1139,6 +1217,7 @@ the delimiter or backslash is interpolated. $baz = '\n'; # a two-character string =item qq/STRING/ +X X X<"> X<""> =item "STRING" @@ -1150,6 +1229,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 @@ -1207,6 +1287,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` @@ -1288,6 +1369,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 @@ -1316,6 +1398,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 @@ -1423,6 +1507,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 @@ -1512,6 +1597,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 @@ -1606,6 +1692,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") @@ -1686,6 +1773,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. @@ -1799,6 +1887,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 @@ -1837,6 +1926,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 @@ -1849,6 +1939,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. @@ -1868,6 +1960,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 @@ -1921,6 +2014,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 @@ -2066,6 +2160,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 @@ -2088,6 +2183,7 @@ 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 @@ -2096,6 +2192,7 @@ 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<~ | & ^>). @@ -2130,6 +2227,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 @@ -2158,6 +2256,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 @@ -2200,6 +2299,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