Perl Operator

Perl has a whole array of very useful operators. They can generally be classified as follows:

• comparison operators
• string operators
• numeric operators
• assignment operators
• equivalence operators

Comparison Operators:

You have to use different operator for numeric and string to accomplish the same task. String operators cannot be used for numeric values and vice versa.

String Operators:

Perl has a rich collection of string operators:

Numeric Operators:

Assignment Operators and Equivalence Operators:

These operators are already defined in the tables above in the context of numeric and string. For example = is an assignment operator and eq is an equivalence operator.

Operators

Autoincrement and Autodecrement

print ++($foo = '99');     # prints '100'

print ++($foo = 'a0');     # prints 'a1'

print ++($foo = 'Az');     # prints 'Ba'

print ++($foo = 'zz');     # prints 'aaa'

Exponentiation

-2**4 is -(2**4), not (-2)**4

Unary Operators

Unary ! performs logical negation which is "not"
Unary - performs arithmetic negation if the operand is numeric. If the operand is an identifier, a string consisting of a minus sign conccatenated with the identifier is returned. Otherwise, if the string starts with a plus or minus, a string starting with the opposite sign is returned.

Unary ~ performs bitwise negation, that is 1's complement.

Unary + has no semantic effect whatsoever, even on strings. It is syntactically useful for separating a function name from a parenthesized expression which would otherwise be interpreted as the complete list of function arguments.

Unary \ creates a reference to whatsoever follows.

Binding Operators

Binary =~ binds a scalar expression to a pattern match, substitution, or translation. These operations search or modify the string $- by default.

Binary !~ is just like =~ except the return value is negated in the logical sense. The following expressions are functionally equivalent:

$string !~ /pattern/
not $string =~ /pattern/

Multiplicative Operators

* / and % work as expected. If you have a floating point use fmod() instead of % because % converts its operands to integers before finding the remainder according to integer division.

Binary x is the repetition operator.

as a string replicator
print '-' x 80;                 
# print row of dashes
print "\t" x ($tab/8), ' ' x ($tab%);    # tab over
as a list replicator
@ones = (1) x 80;                 
# a list of 80 1's
@ones = (5)                  
# set all elements to 5
to initialize array and hash slices
@keys = qw(perls before swine);
@hash{@keys} = ("") x keys;
which is equivalent to
$hash{perls} = '"';
$hash{before} = "";
$hash{swine} = "";

Additive Operators

+ and - convert their arguments from strings to numeric values if necessary and return a numeric result. The "." operator provides string concatenation.

$almost = "Fred" . "Flintshone";           
# returns FredFlintstone
another method of concatenation is
$fullname = "$firstname $lastname";

Shift Operators

The bit-shift operators (<< and >>)

1 << 4;     # returns 16
32 >> 4;       # returns 4

Named Unary and File Test Operators

Some of the functions described in chapter 3 are really unary operators.

sleep 4 | 3  is  equivalent to (sleep 4) | 3
but
print 4 | 3 is equivalent to print (4 | 3)

This is so because sleep is a unary operator and list operator. When in doubt use parenthesis. Remember, if it looks like a function then it is a function.

A file test operator is a unary operator that takes one argument, either a filename or a filehandle, and tests the associated file to see if something is  true about it.

Bitwise Operators

Bitwise AND, OR, and XOR: &, |, and ^. Both operands must be of
the same type.

C-style Logical (Short Circuit) Operators

And: $a && $b       # $a if $a
is false, $b otherwise

Or:   $a || $b           

# $a if $a is true, $b otherwise

open(File, "filename") || die "Cannot open somefile: $!\n";

Range Operator

The range operator .. performs two different tasks. In a list context,
it returns a list of values counting (by ones) from the left value to the
right value.

In scalar context, .. returns a Boolean value.

Angle Operator

The angle operator (<>),
sometimes called a diamond operator, is primarily used for reading and writing
files.