=head1 NAME
X
perlop - Perl operators and precedence
=head1 DESCRIPTION
In Perl, the operator determines what operation is performed,
independent of the type of the operands. For example C
is always a numeric addition, and if C or C do not contain
numbers, an attempt is made to convert them to numbers first.
This is in contrast to many other dynamic languages, where the
operation is determined by the type of the first argument. It also
means that Perl has two versions of some operators, one for numeric
and one for string comparison. For example C compares
two numbers for equality, and C compares two strings.
There are a few exceptions though: C can be either string
repetition or list repetition, depending on the type of the left
operand, and C, C and C can be either string or numeric bit
operations.
=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. goto last next redo dump
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.
The dereferencing cases (as opposed to method-calling cases) are
somewhat extended by the experimental C feature. For the
details of that feature, consult 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 behavior.
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, that is, "not". See also C for a lower
precedence version of this.
X
Unary "-" performs arithmetic negation if the operand is numeric,
including any string that looks like a number. 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, that is, 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
When complementing strings, if all characters have ordinal values under
256, then their complements will, also. But if they do not, all
characters will be in either 32- or 64-bit complements, depending on your
architecture. So for example, C is C on
32-bit machines and C on 64-bit machines.
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. The exceptions are substitution (s///)
and transliteration (y///) with the C (non-destructive) option,
which cause the Beturn value to be the result of the substitution.
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.
Binary "!~" with a non-destructive substitution (s///r) or transliteration
(y///r) is a syntax error.
=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 (that is, 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