X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=pod%2Fperlop.pod;h=442c313c84c6a5be9bc53385cb584619495ea53c;hb=da87341d130e39c7faf9969bc994fd7da37e12ce;hp=3def0ea1eae68d39652317e9c0d557fc4d576b1e;hpb=b159ebd369026559ce72753bffc2fec6cafb7b23;p=p5sagit%2Fp5-mst-13.2.git diff --git a/pod/perlop.pod b/pod/perlop.pod index 3def0ea..442c313 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,11 +41,11 @@ 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 && - left || + left || // nonassoc .. ... right ?: right = += -= *= etc. @@ -34,15 +53,14 @@ values only, not array values. nonassoc list operators (rightward) right not left and - left or xor + left or xor err 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,17 +101,28 @@ 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 constructors C<[]> and C<{}>. See also L toward the end of this section, -as well as L<"I/O Operators">. +as well as L. =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. -"++" 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. + $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 ++; + +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 @@ -127,9 +173,14 @@ character within its range, with carry: print ++($foo = 'Az'); # prints 'Ba' print ++($foo = 'zz'); # prints 'aaa' +C is always treated as numeric, and in particular is changed +to C<0> before incrementing (so that a post-increment of an undef value +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 @@ -137,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 @@ -174,21 +236,24 @@ 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 -time. This can be less efficient than an explicit search, because the -pattern must be compiled every time the expression is evaluated. +time. 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 @@ -196,16 +261,20 @@ C<$a> minus the largest multiple of C<$b> that is not greater than C<$a>. If C<$b> is negative, then C<$a % $b> is C<$a> minus the smallest multiple of C<$b> that is not less than C<$a> (i.e. the result will be less than or equal to zero). -Note than when C is in scope, "%" gives you direct access +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 @@ -216,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 @@ -233,11 +310,23 @@ Binary ">>" returns the value of its left argument shifted right by the number of bits specified by the right argument. Arguments should be integers. (See also L.) +Note that both "<<" and ">>" in Perl are implemented directly using +"<<" and ">>" in C. If C (see L) is +in force then signed C integers are used, else unsigned C integers are +used. Either way, the implementation isn't going to generate results +larger than the size of the integer type Perl was built with (32 bits +or 64 bits). + +The result of overflowing the range of the integers is undefined +because it is undefined also in C. In other words, using 32-bit +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 @@ -262,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 @@ -305,37 +412,61 @@ 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 operators ANDed together bit by bit. +Binary "&" returns its operands ANDed together bit by bit. (See also L and L.) +Note that "&" has lower priority than relational operators, so for example +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 operators ORed together bit by bit. +Binary "|" returns its operands ORed together bit by bit. (See also L and L.) -Binary "^" returns its operators XORed together bit by bit. +Binary "^" returns its operands XORed together bit by bit. (See also L and L.) +Note that "|" and "^" have lower priority than relational operators, so +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. @@ -343,18 +474,31 @@ 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. Scalar or list context propagates down to the right operand if it is evaluated. -The 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 (assuming it's not "0") might be: +=head2 C-style Logical Defined-Or +X X - $home = $ENV{'HOME'} || $ENV{'LOGDIR'} || - (getpwuid($<))[7] || die "You're homeless!\n"; +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 +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. + +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"; In particular, this means that you shouldn't use this for selecting between two aggregates for assignment: @@ -363,10 +507,10 @@ for selecting between two aggregates for assignment: @a = scalar(@b) || @c; # really meant this @a = @b ? @b : @c; # this works fine, though -As more readable alternatives to C<&&> and C<||> when used for -control flow, Perl provides C and C operators (see below). -The short-circuit behavior is identical. The precedence of "and" and -"or" is much lower, however, so that you can safely use them after a +As more readable alternatives to C<&&>, C and C<||> when used for +control flow, Perl provides C, C and C operators (see below). +The short-circuit behavior is identical. The precedence of "and", "err" +and "or" is much lower, however, so that you can safely use them after a list operator without the need for parentheses: unlink "alpha", "beta", "gamma" @@ -380,13 +524,14 @@ 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 an -array of values counting (up by ones) from the left value to the right +operators depending on the context. In list context, it returns a +list of values counting (up by ones) from the left value to the right value. If the left value is greater than the right value then it -returns the empty array. The range operator is useful for writing -C loops and for doing slice operations on arrays. In +returns the empty list. The range operator is useful for writing +C loops and for doing slice operations on arrays. In the current implementation, no temporary array is created when the range operator is used as the expression in C loops, but older versions of Perl might burn a lot of memory when you write something @@ -396,6 +541,9 @@ like this: # code } +The range operator also works on strings, using the magical auto-increment, +see below. + In scalar context, ".." returns a boolean value. The operator is bistable, like a flip-flop, and emulates the line-range (comma) operator of B, B, and various editors. Each ".." operator maintains its @@ -419,26 +567,66 @@ sequence number in a range has the string "E0" appended to it, which doesn't affect its numeric value, but gives you something to search for if you want to exclude the endpoint. You can exclude the beginning point by waiting for the sequence number to be greater -than 1. If either operand of scalar ".." is a constant expression, -that operand is implicitly compared to the C<$.> variable, the -current line number. Examples: +than 1. + +If either operand of scalar ".." is a constant expression, +that operand is considered true if it is equal (C<==>) to the current +input line number (the C<$.> variable). + +To be pedantic, the comparison is actually C, +but that is only an issue if you use a floating point expression; when +implicitly using C<$.> as described in the previous paragraph, the +comparison is C which is only an issue when C<$.> +is set to a floating point value and you are not reading from a file. +Furthermore, C<"span" .. "spat"> or C<2.18 .. 3.14> will not do what +you want in scalar context because each of the operands are evaluated +using their integer representation. + +Examples: As a scalar operator: - if (101 .. 200) { print; } # print 2nd hundred lines - next line if (1 .. /^$/); # skip header lines - s/^/> / if (/^$/ .. eof()); # quote body + if (101 .. 200) { print; } # print 2nd hundred lines, short for + # if ($. == 101 .. $. == 200) ... + + next LINE if (1 .. /^$/); # skip header lines, short for + # ... if ($. == 1 .. /^$/); + # (typically in a loop labeled LINE) + + s/^/> / if (/^$/ .. eof()); # quote body # parse mail messages while (<>) { $in_header = 1 .. /^$/; - $in_body = /^$/ .. eof(); - # do something based on those + $in_body = /^$/ .. eof; + if ($in_header) { + # ... + } else { # in body + # ... + } } continue { - close ARGV if eof; # reset $. each file + close ARGV if eof; # reset $. each file + } + +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"; + } } -As a list operator: +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 @@ -450,7 +638,7 @@ can say @alphabet = ('A' .. 'Z'); -to get all normal letters of the alphabet, or +to get all normal letters of the English alphabet, or $hexdigit = (0 .. 9, 'a' .. 'f')[$num & 15]; @@ -463,7 +651,13 @@ in the sequence that the magical increment would produce, the sequence goes until the next value would be longer than the final value specified. +Because each operand is evaluated in integer form, C<2.18 .. 3.14> will +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 @@ -503,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. @@ -520,8 +717,8 @@ The following are recognized: **= += *= &= <<= &&= -= /= |= >>= ||= - .= %= ^= - x= + .= %= ^= //= + x= Although these are grouped by family, they all have the precedence of assignment. @@ -548,19 +745,44 @@ 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 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. +both its arguments into the list. These arguments are also evaluated +from left to right. + +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 => 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 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. @@ -574,18 +796,23 @@ 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 precedence. This means that it short-circuits: i.e., the right expression is evaluated only if the left expression is true. -=head2 Logical or and Exclusive Or +=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. @@ -608,12 +835,21 @@ takes higher precedence. @info = stat($file) || die; # oops, scalar sense of stat! @info = stat($file) or die; # better, now @info gets its due -Then again, you could always use parentheses. +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')>. 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: @@ -635,31 +871,38 @@ 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 "" qq{} Literal yes - `` qx{} Command yes (unless '' is delimiter) + `` qx{} Command yes* qw{} Word list no - // m{} Pattern match yes (unless '' is delimiter) - qr{} Pattern yes (unless '' is delimiter) - s{}{} Substitution yes (unless '' is delimiter) + // m{} Pattern match yes* + qr{} Pattern yes* + s{}{} Substitution yes* tr{}{} Transliteration no (but see below) + < module on CPAN is able to do this -properly. +is a syntax error. The C module (from CPAN, and +starting from Perl 5.8 part of the standard distribution) is able +to do this properly. There can be whitespace between the operator and the quoting characters, except when C<#> is being used as the quoting character. @@ -679,9 +923,9 @@ from the next line. This allows you to write: s {foo} # Replace foo {bar} # with bar. -For constructs that do interpolate, variables beginning with "C<$>" -or "C<@>" are interpolated, as are the following escape sequences. Within -a transliteration, the first eleven of these sequences may be used. +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) @@ -694,7 +938,14 @@ a transliteration, the first eleven of these sequences may be used. \x1b hex char (ESC) \x{263a} wide hex char (SMILEY) \c[ control char (ESC) - \N{name} named char + \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 @@ -703,9 +954,12 @@ a transliteration, the first eleven of these sequences may be used. \E end case modification \Q quote non-word characters till \E -If C is in effect, the case map used by C<\l>, C<\L>, C<\u> -and C<\U> is taken from the current locale. See L. For -documentation of C<\N{name}>, see L. +If C is in effect, the case map used by C<\l>, C<\L>, +C<\u> and C<\U> is taken from the current locale. See L. +If Unicode (for example, C<\N{}> or wide hex characters of 0x100 or +beyond) is being used, the case map used by C<\l>, C<\L>, C<\u> and +C<\U> is as defined by Unicode. For documentation of C<\N{name}>, +see L. All systems use the virtual C<"\n"> to represent a line terminator, called a "newline". There is no such thing as an unvarying, physical @@ -720,6 +974,18 @@ 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 +C<< $href->{key}[0] >> are also interpolated, as are array and hash slices. +But method calls such as C<< $obj->meth >> are not. + +Interpolating an array or slice interpolates the elements in order, +separated by the value of C<$">, so is equivalent to interpolating +C. "Punctuation" arrays such as C<@+> are only +interpolated if the name is enclosed in braces C<@{+}>. You cannot include a literal C<$> or C<@> within a C<\Q> sequence. An unescaped C<$> or C<@> interpolates the corresponding variable, @@ -739,6 +1005,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. @@ -746,6 +1013,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 @@ -766,6 +1034,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 @@ -807,7 +1078,20 @@ that you won't change the variables in the pattern. If you change them, Perl won't even notice. See also L<"qr/STRING/imosx">. If the PATTERN evaluates to the empty string, the last -I matched regular expression is used instead. +I matched regular expression is used instead. In this +case, only the C and C flags on the empty pattern is honoured - +the other flags are taken from the original pattern. If no match has +previously succeeded, this will (silently) act instead as a genuine +empty pattern (which will always match). + +Note that it's possible to confuse Perl into thinking C (the empty +regex) is really C (the defined-or operator). Perl is usually pretty +good about this, but some pathological cases might trigger this, such as +C<$a///> (is that C<($a) / (//)> or C<$a // />?) and C +(C or C?). In all of these examples, Perl +will assume you meant defined-or. If you meant the empty regex, just +use parentheses or spaces to disambiguate, or even prefix the empty +regex with an C (so C becomes C). If the C option is not used, C in list context returns a list consisting of the subexpressions matched by the parentheses in the @@ -861,7 +1145,8 @@ C, if any, left off. Without the C modifier, the C<\G> assertion still anchors at pos(), but the match is of course only attempted once. Using C<\G> without C on a target string that has not previously had a C match applied to it is the same as using the C<\A> assertion to match -the beginning of the string. +the beginning of the string. Note also that, currently, C<\G> is only +properly supported when anchored at the very beginning of the pattern. Examples: @@ -933,6 +1218,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'> @@ -945,6 +1231,7 @@ the delimiter or backslash is interpolated. $baz = '\n'; # a two-character string =item qq/STRING/ +X X X<"> X<""> =item "STRING" @@ -956,6 +1243,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 @@ -1013,6 +1301,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` @@ -1046,10 +1335,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: @@ -1091,9 +1380,10 @@ when they're the right way to get something done. Perl was made to be a glue language, and one of the things it glues together is commands. Just understand what you're getting yourself into. -See L<"I/O Operators"> for more discussion. +See L 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 @@ -1101,7 +1391,8 @@ equivalent to: split(' ', q/STRING/); -the difference being that it generates a real list at compile time. So +the differences being that it generates a real list at compile time, and +in scalar context it returns the last element in the list. So this expression: qw(foo bar baz) @@ -1121,6 +1412,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 @@ -1205,9 +1498,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+$//; } @@ -1228,6 +1521,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 @@ -1316,9 +1610,103 @@ 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 +the quoted material, and all lines following the current line down to +the terminating string are the value of the item. The terminating +string may be either an identifier (a word), or some quoted text. If +quoted, the type of quotes you use determines the treatment of the +text, just as in regular quoting. An unquoted identifier works like +double quotes. There must be no space between the C<< << >> and +the identifier, unless the identifier is quoted. (If you put a space it +will be treated as a null identifier, which is valid, and matches the first +empty line.) The terminating string must appear by itself (unquoted and +with no surrounding whitespace) on the terminating line. + + print <, +the quoted material must come on the lines following the final delimiter. +So instead of + + s/this/<. + +Additionally, the quoting rules for the identifier are not related to +Perl's quoting rules -- C, C, and the like are not supported +in place of C<''> and C<"">, and the only interpolation is for backslashing +the quoting character: + + print << "abc\"def"; + testing... + abc"def + +Finally, quoted strings cannot span multiple lines. The general rule is +that the identifier must be a string literal. Stick with that, and you +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") @@ -1381,6 +1769,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 @@ -1394,6 +1787,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. @@ -1497,7 +1891,7 @@ alphanumeric char, as in: In the RE above, which is intentionally obfuscated for illustration, the delimiter is C, the modifier is C, and after backslash-removal the -RE is the same as for C). There's more than one +RE is the same as for C. There's more than one reason you're encouraged to restrict your delimiters to non-alphanumeric, non-whitespace choices. @@ -1507,6 +1901,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 @@ -1545,6 +1940,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 @@ -1557,6 +1953,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. @@ -1576,6 +1974,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 @@ -1629,6 +2028,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 @@ -1717,7 +2117,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 @@ -1773,6 +2174,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 @@ -1794,7 +2196,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<~ | & ^>). @@ -1817,8 +2229,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) @@ -1829,6 +2241,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 @@ -1853,10 +2266,11 @@ L.) However, C still has meaning for them. By default, their results are interpreted as unsigned integers, but if C is in effect, their results are interpreted as signed integers. For example, C<~0> usually evaluates to a large -integral value. However, C is C<-1> on twos-complement +integral value. However, C is C<-1> on two's-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 @@ -1899,6 +2313,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