GIF89a;
toward the end of this section, as well as L"I/O Operators">. =head2 The Arrow Operator XX 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 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<0> before incrementing (so that a post-increment of an undef value will return C<0> 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<0666 & ~027> 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<~"\x{3B1}"> is C<"\x{FFFF_FC4E}"> on 32-bit machines and C<"\x{FFFF_FFFF_FFFF_FC4E}"> 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 B eturn 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<$a> and C<$b>: If C<$b> is positive, then C<$a % $b> is C<$a> minus the largest multiple of C<$b> less than or equal to C<$a>. If C<$b> is negative, then C<$a % $b> is C<$a> minus the smallest multiple of C<$b> that is not less than C<$a> (that is, the result will be less than or equal to zero). If the operands C<$a> and C<$b> are floating point values and the absolute value of C<$b> (that is C ) is less than C<(UV_MAX + 1)>, only the integer portion of C<$a> and C<$b> 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<(UV_MAX + 1)>, "%" computes the floating-point remainder C<$r> in the equation C<($r = $a - $i*$b)> where C<$i> is a certain integer that makes C<$r> have the same sign as the right operand C<$b> (B as the left operand C<$a> like C function C ) and the absolute value less than that of C<$b>. Note that when C