Perl Operators and Precedence

0 is highest precedence.

Associativity	Operator	Prece- dence	Meaning
left	( )	0	terms (includes: variables, quote-like operators, expressions in parenthesis, any function whose arguments are parenthesized
left	print(), chdir()	0	list operators. In the absence of parenthesis, the precedence of list operators such as "print", "sort", "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); 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.
left	->	?	Infix dereference or field selector as in C/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.
nonassoc	++ --	?	Auto-increment (++), auto-decrement (--). If placed before the variable the increment/decrement of the variable takes place before returning the value, and if placed after, increment/decrement the variable after returning the value.
right	**	?	Exponentiation
right	! ~ \ unary + unary -	?	boolean or logical: not (2) bitwise: not (1) ??? unary plus unary minus
left	=~ !~	?	True if left string matches with regular expression on right. True if left string does not have a match with regular expression on right. (Note.A: Literal string in the regex on right can be replaced with a variable: /$var/) (Note.B: If matching against "$_", the "$_ =~" can be omitted: $_ = "Hello World"; print "ok" if /World/;)
left	* / % x	?	multiply divide modulo string repeat
left	+ - .	?	add subtract string concatenate
left	<< >>	?	shift left shift right
nonassoc	???	?	named unary operators
nonassoc	< > <= >= lt gt le ge	?	arithmetic compare string compare
nonassoc	== != <=> eq ne cmp	?	arithmetic: equal, not equal, compare string: equal, not equal, compare
left	& \| ^	?	bitwise: and, or, xor (1)
left	&& \|\|	?	boolean or logical: and, or (2)
nonassoc	.. ...	?	range (3)
right	? :	?	conditional, e.g.: test_expr?true_expr:false_expr
right	= *= += -= .= = /= %= x= &= \|= ^= <<= >>= &&= \|\|=	?	assignment (with operation) $var OP= $expr; # is same as: $var = $var OP $expr; Be careful of post/pre increment/decrement operators on left side in terms of number of times executed!
left	, =>	?	comma (4) key value separator in hash list (comma synonym)
nonassoc	( , , , )	?	list operators (rightward)
right	not	?	boolean or logical (2)
left	and or xor	?	boolean or logical (2)

Notes:

1) Bitwise operators operate on machine dependent size int if one or more operans are int. For strings it works on the bytes (zero filling the shorter string). If one operand is a string and one is an int, e.g. "123.45" & 234.56 then the string is converetd to a cnumber and noth numbers are converted to in giving 123 & 234 yielding 106. While "123.45" & "234.56" gives another string: "020.44".

2) As in C, logical operands evaluate left to right (subject to precedence) and stop (short circuit) once a true has been evaluated. There is no C equivalent to xor since the ^ operator in operates on bits.

3) The range operator is two different operators depending on the context. In a list context, it returns a list of values (counting by 1) from the left value to the right value. In a scalar context .. returns a boolean value. The operator is bi-stable (like a flip-flop). Each .. operator has its own boolean state. It is false as long as its left operand is false. Once the left operand is true, the range operator stays true until the right operand is true, after which the range operator becomes false again. The operator does not become false again until the next time it is evaluated. It can test the right oeprand and become false on the same evaluation as the one where it becomes true, but it still returns true. If you don't want it to test the right operand until the next evaluation use three dots ... (instead of two). The value returned is either a null string for false, or a sequence number (beginning with 1) for true. The sequence number is reset for each range encountered. The final sequence number in a range has the string "E)" appended to it (which doesn't affect its numeric value, but gives you something to search for to exclude the endpoint.

4) The comma operator in a scalar context evaluates the left most expression (i.e. before the 1st comma) and then return the value of the second expression. For example: $a=(4,9); # $a gets 9. While @a=(4,9); # builds a two element list: $a[0]=4; $a[1]=9;.