|
perlop - Perl operators and precedence
Operator precedence and associativity work in Perl more or less like
they do in mathematics.
Operator precedence means some operators are evaluated before
others. For example, in 2 + 4 * 5, the multiplication has higher
precedence so 4 * 5 is evaluated first yielding 2 + 20 ==
22 and not 6 * 5 == 30.
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 8
- 4 - 2, subtraction is left associative so Perl evaluates the
expression left to right. 8 - 4 is evaluated first making the
expression 4 - 2 == 2 and not 8 - 2 == 6.
Perl operators have the following associativity and precedence,
listed from highest precedence to lowest. Operators borrowed from
C keep the same precedence relationship with each other, even where
C's precedence is slightly screwy. (This makes learning Perl easier
for C folks.) With very few exceptions, these all operate on scalar
values only, not array values.
left terms and list operators (leftward)
left ->
nonassoc ++ --
right **
right ! ~ \ and unary + and -
left =~ !~
left * / % x
left + - .
left << >>
nonassoc named unary operators
nonassoc < > <= >= lt gt le ge
nonassoc == != <=> eq ne cmp ~~
left &
left | ^
left &&
left || //
nonassoc .. ...
right ?:
right = += -= *= etc.
left , =>
nonassoc list operators (rightward)
right not
left and
left or xor
In the following sections, these operators are covered in precedence order.
Many operators can be overloaded for objects. See the overload manpage.
A TERM has the highest precedence in Perl. They include variables,
quote and quote-like operators, any expression in parentheses,
and any function whose arguments are parenthesized. Actually, there
aren't really functions in this sense, just list operators and unary
operators behaving as functions because you put parentheses around
the arguments. These are all documented in the perlfunc manpage.
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
arguments within parentheses are taken to be of highest precedence,
just like a normal function call.
In the absence of parentheses, the precedence of list operators such as
print, sort, or chmod is either very high or very low depending on
whether you are looking at the left side or the right side of the operator.
For example, in
@ary = (1, 3, sort 4, 2);
print @ary;
the commas on the right of the sort are evaluated before the sort,
but the commas on the left are evaluated after. In other words,
list operators tend to gobble up all arguments that follow, and
then act like a simple TERM with regard to the preceding expression.
Be careful with parentheses:
print($foo, exit);
print $foo, exit;
(print $foo), exit;
print($foo), exit;
print ($foo), exit;
Also note that
print ($foo & 255) + 1, "\n";
probably doesn't do what you expect at first glance. The parentheses
enclose the argument list for print which is evaluated (printing
the result of $foo & 255). Then one is added to the return value
of print (usually 1). The result is something like this:
1 + 1, "\n";
To do what you meant properly, you must write:
print(($foo & 255) + 1, "\n");
See Named Unary Operators for more discussion of this.
Also parsed as terms are the do {} and eval {} constructs, as
well as subroutine and method calls, and the anonymous
constructors [] and {}.
See also Quote and Quote-like Operators toward the end of this section,
as well as I/O Operators.
"->" is an infix dereference operator, just as it is in C
and C++. If the right side is either a [...], {...}, or a
(...) subscript, then the left side must be either a hard or
symbolic reference to an array, a hash, or a subroutine respectively.
(Or technically speaking, a location capable of holding a hard
reference, if it's an array or hash reference being used for
assignment.) See the perlreftut manpage and the perlref manpage.
Otherwise, the right side is a method name or a simple scalar
variable containing either the method name or a subroutine reference,
and the left side must be either an object (a blessed reference)
or a class name (that is, a package name). See the perlobj manpage.
"++" and "--" work as in C. That is, if placed before a variable,
they increment or decrement the variable by one before returning the
value, and if placed after, increment or decrement after returning the
value.
$i = 0; $j = 0;
print $i++;
print ++$j;
Note that just as in C, Perl doesn't define 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
a numeric context, you get a normal increment. If, however, the
variable has been used in only string contexts since it was set, and
has a value that is not the empty string and matches the pattern
/^[a-zA-Z]*[0-9]*\z/, the increment is done as a string, preserving each
character within its range, with carry:
print ++($foo = '99');
print ++($foo = 'a0');
print ++($foo = 'Az');
print ++($foo = 'zz');
undef is always treated as numeric, and in particular is changed
to 0 before incrementing (so that a post-increment of an undef value
will return 0 rather than undef).
The auto-decrement operator is not magical.
Binary "**" is the exponentiation operator. It binds even more
tightly than unary minus, so -2**4 is -(2**4), not (-2)**4. (This is
implemented using C's pow(3) function, which actually works on doubles
internally.)
Unary "!" performs logical negation, i.e., "not". See also not for a lower
precedence version of this.
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 -bareword is equivalent
to the string "-bareword". If, however, the string begins with a
non-alphabetic character (excluding "+" 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
Argument "the string" isn't numeric in negation (-) at ....
Unary "~" performs bitwise negation, i.e., 1's complement. For
example, 0666 & ~027 is 0640. (See also Integer Arithmetic and
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 to use the & operator to mask off the excess bits.
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 Terms and List Operators (Leftward).)
Unary "\" creates a reference to whatever follows it. See the perlreftut manpage
and the perlref manpage. 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.
Binary "=~" binds a scalar expression to a pattern match. Certain operations
search or modify the string $_ by default. This operator makes that kind
of operation work on some other string. The right argument is a search
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 Regexp Quote-Like Operators for details and
the perlretut manpage 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. Note that this means that its contents will be interpolated twice, so
'\\' =~ q'\\';
is not ok, as the regex engine will end up trying to compile the
pattern \, which it will consider a syntax error.
Binary "!~" is just like "=~" except the return value is negated in
the logical sense.
Binary "*" multiplies two numbers.
Binary "/" divides two numbers.
Binary "%" computes the modulus of two numbers. Given integer
operands $a and $b: If $b is positive, then $a % $b is
$a minus the largest multiple of $b that is not greater than
$a. If $b is negative, then $a % $b is $a minus the
smallest multiple of $b that is not less than $a (i.e. the
result will be less than or equal to zero). If the operands
$a and $b are floating point values and the absolute value of
$b (that is abs($b)) is less than (UV_MAX + 1), only
the integer portion of $a and $b will be used in the operation
(Note: here UV_MAX means the maximum of the unsigned integer type).
If the absolute value of the right operand (abs($b)) is greater than
or equal to (UV_MAX + 1), "%" computes the floating-point remainder
$r in the equation ($r = $a - $i*$b) where $i is a certain
integer that makes $r should have the same sign as the right operand
$b (not as the left operand $a like C function fmod())
and the absolute value less than that of $b.
Note that when use integer 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.
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 or is a list formed by 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.
print '-' x 80;
print "\t" x ($tab/8), ' ' x ($tab%8);
@ones = (1) x 80;
@ones = (5) x @ones;
Binary "+" returns the sum of two numbers.
Binary "-" returns the difference of two numbers.
Binary "." concatenates two strings.
Binary "<<" returns the value of its left argument shifted left by the
number of bits specified by the right argument. Arguments should be
integers. (See also Integer Arithmetic.)
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 Integer Arithmetic.)
Note that both "<<" and ">>" in Perl are implemented directly using
"<<" and ">>" in C. If use integer (see Integer Arithmetic) 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, 1 << 32 is undefined. Shifting by a negative number
of bits is also undefined.
The various named unary operators are treated as functions with one
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
arguments within parentheses are taken to be of highest precedence,
just like a normal function call. For example,
because named unary operators are higher precedence than ||:
chdir $foo || die;
chdir($foo) || die;
chdir ($foo) || die;
chdir +($foo) || die;
but, because * is higher precedence than named operators:
chdir $foo * 20;
chdir($foo) * 20;
chdir ($foo) * 20;
chdir +($foo) * 20;
rand 10 * 20;
rand(10) * 20;
rand (10) * 20;
rand +(10) * 20;
Regarding precedence, the fi | 
