=head1 NAME
X
perlop - Perl operators and precedence
=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, the multiplication has higher
precedence so C is evaluated first yielding C and not C.
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, subtraction is left associative so Perl evaluates the
expression left to right. C is evaluated first making the
expression C and not C.
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 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,
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 L.
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
C, C, or C 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; # prints 1324
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:
# These evaluate exit before doing the print:
print($foo, exit); # Obviously not what you want.
print $foo, exit; # Nor is this.
# These do the print before evaluating exit:
(print $foo), exit; # This is what you want.
print($foo), exit; # Or this.
print ($foo), exit; # Or even this.
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 C which is evaluated (printing
the result of C). 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">.
=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
C 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 L and L.
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 L.
=head2 Auto-increment and Auto-decrement
X X X X X X
"++" and "--" work as in C. That is, if placed before a variable,
they increment or decrement the variable by one before returning the
value, and if placed after, increment or decrement after returning the
value.
$i = 0; $j = 0;
print $i++; # prints 0
print ++$j; # prints 1
Note that just as in C, Perl doesn't define B the variable is
incremented or decremented. You just know it will be done sometime
before or after the value is returned. This also means that modifying
a variable twice in the same statement will lead to undefined behaviour.
Avoid statements like:
$i = $i ++;
print ++ $i + $i ++;
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
C^[a-zA-Z]*[0-9]*\z/>, the increment is done as a string, preserving each
character within its range, with carry:
print ++($foo = '99'); # prints '100'
print ++($foo = 'a0'); # prints 'a1'
print ++($foo = 'Az'); # prints 'Ba'
print ++($foo = 'zz'); # prints 'aaa'
C is always treated as numeric, and in particular is changed
to C before incrementing (so that a post-increment of an undef value
will return C 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
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 -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
B.
X X
Unary "~" performs bitwise negation, i.e., 1's complement. For
example, C 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 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
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 L"Regexp Quote-Like Operators"> 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. 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 C, which it will consider a syntax error.
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 "%" is the modulo operator, which computes the division
remainder of its first argument with respect to its second argument.
Given integer
operands C and C: If C is positive, then C is
C minus the largest multiple of C less than or equal to
C. If C is negative, then C is C minus the
smallest multiple of C that is not less than C (i.e. the
result will be less than or equal to zero). If the operands
C and C are floating point values and the absolute value of
C (that is C) is less than C, only
the integer portion of C and C will be used in the operation
(Note: here C means the maximum of the unsigned integer type).
If the absolute value of the right operand (C) is greater than
or equal to C, "%" computes the floating-point remainder
C in the equation C where C is a certain
integer that makes C have the same sign as the right operand
C (B as the left operand C like C function C)
and the absolute value less than that of C.
Note that when C