=head1 NAME
+X<operator>
perlop - Perl operators and precedence
-=head1 SYNOPSIS
+=head1 DESCRIPTION
+
+=head2 Operator Precedence and Associativity
+X<operator, precedence> X<precedence> X<associativity>
+
+Operator precedence and associativity work in Perl more or less like
+they do in mathematics.
+
+I<Operator precedence> 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<Operator associativity> 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
left << >>
nonassoc named unary operators
nonassoc < > <= >= lt gt le ge
- nonassoc == != <=> eq ne cmp
+ nonassoc == != <=> eq ne cmp ~~
left &
left | ^
left &&
Many operators can be overloaded for objects. See L<overload>.
-=head1 DESCRIPTION
-
=head2 Terms and List Operators (Leftward)
+X<list operator> X<operator, list> X<term>
A TERM has the highest precedence in Perl. They include variables,
quote and quote-like operators, any expression in parentheses,
print ($foo & 255) + 1, "\n";
-probably doesn't do what you expect at first glance. See
-L<Named Unary Operators> for more discussion of this.
+probably doesn't do what you expect at first glance. The parentheses
+enclose the argument list for C<print> which is evaluated (printing
+the result of C<$foo & 255>). Then one is added to the return value
+of C<print> (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<Named Unary Operators> for more discussion of this.
Also parsed as terms are the C<do {}> and C<eval {}> constructs, as
well as subroutine and method calls, and the anonymous
constructors C<[]> and C<{}>.
See also L<Quote and Quote-like Operators> toward the end of this section,
-as well as L<"I/O Operators">.
+as well as L</"I/O Operators">.
=head2 The Arrow Operator
+X<arrow> X<dereference> 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
or a class name (that is, a package name). See L<perlobj>.
=head2 Auto-increment and Auto-decrement
+X<increment> X<auto-increment> X<++> X<decrement> X<auto-decrement> 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<when> 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
print ++($foo = 'Az'); # prints 'Ba'
print ++($foo = 'zz'); # prints 'aaa'
+C<undef> 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<undef>).
+
The auto-decrement operator is not magical.
=head2 Exponentiation
+X<**> X<exponentiation> X<power>
Binary "**" is the exponentiation operator. It binds even more
tightly than unary minus, so -2**4 is -(2**4), not (-2)**4. (This is
internally.)
=head2 Symbolic Unary Operators
+X<unary operator> X<operator, unary>
Unary "!" performs logical negation, i.e., "not". See also C<not> 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<Argument "the string" isn't numeric in negation (-) at ...>.
+X<-> X<negation, arithmetic>
Unary "~" performs bitwise negation, i.e., 1's complement. For
example, C<0666 & ~027> is 0640. (See also L<Integer Arithmetic> and
L<Bitwise String Operators>.) 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<negation, binary>
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<Terms and List Operators (Leftward)>.)
+X<+>
Unary "\" creates a reference to whatever follows it. See L<perlreftut>
and L<perlref>. 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<reference> X<backslash>
=head2 Binding Operators
+X<binding> X<operator, binding> 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
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</"Regexp Quote-Like Operators"> for details.
+operator. See L</"Regexp Quote-Like Operators"> for details and
+L<perlretut> 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<operator, multiplicative>
Binary "*" multiplies two numbers.
+X<*>
Binary "/" divides two numbers.
+X</> X<slash>
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
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<remainder> X<modulus> X<mod>
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<qw/STRING/>, 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<x>
print '-' x 80; # print row of dashes
=head2 Additive Operators
+X<operator, additive>
Binary "+" returns the sum of two numbers.
+X<+>
Binary "-" returns the difference of two numbers.
+X<->
Binary "." concatenates two strings.
+X<string, concatenation> X<concatenation>
+X<cat> X<concat> X<concatenate> X<.>
=head2 Shift Operators
+X<shift operator> X<operator, shift> X<<< << >>>
+X<<< >> >>> X<right shift> X<left shift> X<bitwise shift>
+X<shl> X<shr> X<shift, right> X<shift, left>
Binary "<<" returns the value of its left argument shifted left by the
number of bits specified by the right argument. Arguments should be
of bits is also undefined.
=head2 Named Unary Operators
+X<operator, named unary>
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<perlfunc>.
+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
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<filetest> X<operator, filetest>
+
See also L<"Terms and List Operators (Leftward)">.
=head2 Relational Operators
+X<relational operator> X<operator, relational>
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<equality> X<equal> X<equals> X<operator, equality>
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
"<=" 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<spaceship>
- 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<eq>
Binary "ne" returns true if the left argument is stringwise not equal
to the right argument.
+X<ne>
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<cmp>
+
+Binary "~~" does a smart match between its arguments. Smart matching
+is described in L<perlsyn/"Smart Matching in Detail">.
+This operator is only available if you enable the "~~" feature:
+see L<feature> for more information.
+X<~~>
"lt", "le", "ge", "gt" and "cmp" use the collation (sort) order specified
by the current locale if C<use locale> is in effect. See L<perllocale>.
=head2 Bitwise And
+X<operator, bitwise, and> X<bitwise and> X<&>
Binary "&" returns its operands ANDed together bit by bit.
(See also L<Integer Arithmetic> and L<Bitwise String Operators>.)
print "Even\n" if ($x & 1) == 0;
=head2 Bitwise Or and Exclusive Or
+X<operator, bitwise, or> X<bitwise or> X<|> X<operator, bitwise, xor>
+X<bitwise xor> X<^>
Binary "|" returns its operands ORed together bit by bit.
(See also L<Integer Arithmetic> and L<Bitwise String Operators>.)
print "false\n" if (8 | 2) != 10;
=head2 C-style Logical And
+X<&&> X<logical and> X<operator, logical, and>
Binary "&&" performs a short-circuit logical AND operation. That is,
if the left operand is false, the right operand is not even evaluated.
is evaluated.
=head2 C-style Logical Or
+X<||> X<operator, logical, or>
Binary "||" performs a short-circuit logical OR operation. That is,
if the left operand is true, the right operand is not even evaluated.
is evaluated.
=head2 C-style Logical Defined-Or
+X<//> X<operator, logical, defined-or>
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
is similar to C<defined($a) || $b> (except that it returns the value of C<$a>
rather than the value of C<defined($a)>) and is exactly equivalent to
C<defined($a) ? $a : $b>. 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<defined($a // $b)>.
+for variables. If you actually want to test if at least one of C<$a> and
+C<$b> is defined, use C<defined($a // $b)>.
-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";
Using "or" for assignment is unlikely to do what you want; see below.
=head2 Range Operators
+X<operator, range> X<range> X<..> X<...>
Binary ".." is the range operator, which is really two different
-operators depending on the context. In list context, it returns an
+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
+returns the empty list. The range operator is useful for writing
C<foreach (1..10)> 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<foreach> loops, but older
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<int(EXPR) == int(EXPR)>,
+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<int(EXPR) == int($.)> 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
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<operator, conditional> X<operator, ternary> X<ternary> 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
$a += ($a % 2) ? 10 : 2;
=head2 Assignment Operators
+X<assignment> X<operator, assignment> X<=> X<**=> X<+=> X<*=> X<&=>
+X<<< <<= >>> X<&&=> X<-=> X</=> X<|=> X<<< >>= >>> X<||=> X<//=> X<.=>
+X<%=> X<^=> X<x=>
"=" is the ordinary assignment operator.
**= += *= &= <<= &&=
-= /= |= >>= ||=
- .= %= ^=
- x=
+ .= %= ^= //=
+ x=
Although these are grouped by family, they all have the precedence
of assignment.
side of the assignment.
=head2 Comma Operator
+X<comma> X<operator, comma> 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:
-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.
+ my %h = ("FOO", 23);
+
+It is I<NOT>:
+
+ 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<operator, list, rightward> X<list operator>
On the right side of a list operator, it has very low precedence,
such that it controls all comma-separated expressions found there.
See also discussion of list operators in L<Terms and List Operators (Leftward)>.
=head2 Logical Not
+X<operator, logical, not> X<not>
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<operator, logical, and> X<and>
Binary "and" returns the logical conjunction of the two surrounding
expressions. It's equivalent to && except for the very low
expression is evaluated only if the left expression is true.
=head2 Logical or, Defined or, and Exclusive Or
+X<operator, logical, or> X<operator, logical, xor> X<operator, logical, err>
+X<operator, logical, defined or> X<operator, logical, exclusive or>
+X<or> X<xor> X<err>
Binary "or" returns the logical disjunction of the two surrounding
expressions. It's equivalent to || except for the very low 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<undef> on an B<err>or,
-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<undef> on
+an B<err>or, or as a sort of correction: C<$a = ($b err 'default')>. This
+keyword is only available when the 'err' feature is enabled: see
+L<feature> 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<operator, missing from perl> X<&> X<*>
+X<typecasting> X<(TYPE)>
Here is what C has that Perl doesn't:
=back
=head2 Quote and Quote-like Operators
+X<operator, quote> X<operator, quote-like> X<q> X<qq> X<qx> X<qw> X<m>
+X<qr> X<s> X<tr> X<'> X<''> X<"> X<""> X<//> X<`> X<``> X<<< << >>>
+X<escape sequence> X<escape>
+
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
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'
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)
\c[ control char (ESC)
\N{name} named Unicode character
+B<NOTE>: 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
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<newline> X<line terminator> X<eol> X<end of line>
+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
variables when used within double quotes.
=head2 Regexp Quote-Like Operators
+X<operator, regexp>
Here are the quote-like operators that apply to pattern
matching and related activities.
=over 8
=item ?PATTERN?
+X<?>
This is just like the C</pattern/> search, except that it matches only
once between calls to the reset() operator. This is a useful
around the year 2168.
=item m/PATTERN/cgimosx
+X<m> X<operator, match>
+X<regexp, options> X<regexp> X<regex, options> X<regex>
+X</c> X</i> X</m> X</o> X</s> X</x>
=item /PATTERN/cgimosx
MiXeD line-noise. That's all!
=item q/STRING/
+X<q> X<quote, double> X<'> X<''>
=item C<'STRING'>
$baz = '\n'; # a two-character string
=item qq/STRING/
+X<qq> X<quote, double> X<"> X<"">
=item "STRING"
$baz = "\n"; # a one-character string
=item qr/STRING/imosx
+X<qr> X</i> X</m> X</o> X</s> X</x>
This operator quotes (and possibly compiles) its I<STRING> as a regular
expression. I<STRING> is interpolated the same way as I<PATTERN>
for a detailed look at the semantics of regular expressions.
=item qx/STRING/
+X<qx> X<`> X<``> X<backtick>
=item `STRING`
$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:
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</"I/O Operators"> for more discussion.
=item qw/STRING/
+X<qw> X<quote, list> X<quote, words>
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
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)
produces warnings if the STRING contains the "," or the "#" character.
=item s/PATTERN/REPLACEMENT/egimosx
+X<substitute> X<substitution> X<replace> X<regexp, replace>
+X<regexp, substitute> X</e> X</g> X</i> X</m> X</o> X</s> X</x>
Searches a string for a pattern, and if found, replaces that pattern
with the replacement text and returns the number of substitutions
\*/ # 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+$//;
}
1 while s/\t+/' ' x (length($&)*8 - length($`)%8)/e;
=item tr/SEARCHLIST/REPLACEMENTLIST/cds
+X<tr> X<y> X<transliterate> X</c> X</d> X</s>
=item y/SEARCHLIST/REPLACEMENTLIST/cds
eval "tr/$oldlist/$newlist/, 1" or die $@;
=item <<EOF
+X<here-doc> X<heredoc> X<here-document> X<<< << >>>
A line-oriented form of quoting is based on the shell "here-document"
syntax. Following a C<< << >> you specify a string to terminate
=back
=head2 Gory details of parsing quoted constructs
+X<quote, gory details>
When presented with something that might have several different
interpretations, Perl uses the B<DWIM> (that's "Do What I Mean")
the example above is not C<m//x>, but rather C<m//> with no C</x>
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<qq/\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
used in parsing.
=item Interpolation
+X<interpolation>
The next step is interpolation in the text obtained, which is now
delimiter-independent. There are four different cases.
In the RE above, which is intentionally obfuscated for illustration, the
delimiter is C<m>, the modifier is C<mx>, and after backslash-removal the
-RE is the same as for C<m/ ^ a s* b /mx>). There's more than one
+RE is the same as for C<m/ ^ a \s* b /mx>. There's more than one
reason you're encouraged to restrict your delimiters to non-alphanumeric,
non-whitespace choices.
which are processed further.
=item Interpolation of regular expressions
+X<regexp, interpolation>
Previous steps were performed during the compilation of Perl code,
but this one happens at run time--although it may be optimized to
switch documented in L<perlrun/"Command Switches">.
=item Optimization of regular expressions
+X<regexp, optimization>
This step is listed for completeness only. Since it does not change
semantics, details of this step are not documented and are subject
=back
=head2 I/O Operators
+X<operator, i/o> X<operator, io> X<io> X<while> X<filehandle>
+X<< <> >> X<@ARGV>
There are several I/O operators you should know about.
backslash. The generalized form of backticks is C<qx//>. (Because
backticks always undergo shell expansion as well, see L<perlsec> for
security concerns.)
+X<qx> X<`> X<``> X<backtick> X<glob>
In scalar context, evaluating a filehandle in angle brackets yields
the next line from that file (the newline, if any, included), or
rather than global.) Additional filehandles may be created with
the open() function, amongst others. See L<perlopentut> and
L<perlfunc/open> for details on this.
+X<stdin> X<stdout> X<sterr>
If a <FILEHANDLE> is used in a context that is looking for
a list, a list comprising all input lines is returned, one line per
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<glob("$x ")>, not C<readline($x)>.
One level of double-quote interpretation is done first, but you can't
say C<< <$foo> >> because that's an indirect filehandle as explained
@files = glob($files[$i]);
=head2 Constant Folding
+X<constant folding> X<folding>
Like C, Perl does a certain amount of expression evaluation at
compile time whenever it determines that all arguments to an
the compiler will precompute the number which that expression
represents so that the interpreter won't have to.
+=head2 No-ops
+X<no-op> X<nop>
+
+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<operator, bitwise, string>
Bitstrings of any size may be manipulated by the bitwise operators
(C<~ | & ^>).
a B<numeric> 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)
in a bit vector.
=head2 Integer Arithmetic
+X<integer>
By default, Perl assumes that it must do most of its arithmetic in
floating point. But by saying
them. By default, their results are interpreted as unsigned integers, but
if C<use integer> is in effect, their results are interpreted
as signed integers. For example, C<~0> usually evaluates to a large
-integral value. However, C<use integer; ~0> is C<-1> on twos-complement
+integral value. However, C<use integer; ~0> is C<-1> on two's-complement
machines.
=head2 Floating-point Arithmetic
+X<floating-point> X<floating point> X<float> X<real>
While C<use integer> provides integer-only arithmetic, there is no
analogous mechanism to provide automatic rounding or truncation to a
need yourself.
=head2 Bigger Numbers
+X<number, arbitrary precision>
The standard Math::BigInt and Math::BigFloat modules provide
variable-precision arithmetic and overloaded operators, although
projects / p5sagit/p5-mst-13.2.git / blobdiff