04 - Operators

The operators in a computer language tell the computer what actions to perform. Perl has more operators than most languages. You've already seen some operators - like the equals or assignment operator(=) - in this book. As you read about the other operators, you'll undoubtedly realize that you are familiar with some of them. Trust your intuition; the definitions that you already know will probably still be true.

Operators are instructions you give to the computer so that it can perform some task or operation. All operators cause actions to be performed on operands. An operand can be anything that you perform an operation on. In practical terms, any particular operand will be a literal, a variable, or an expression. You've already been introduced to literals and variables. A good working definition of expression is some combination of operators and operands that are evaluated as a unit. Chapter 6, "Statements," has more information about expressions.

Operands are also recursive in nature. In Perl, the expression 3 + 5 (two operands and a plus operator) can be considered as one operand with a value of 8. For instance, (3 + 5) - 12 is an expression that consists of two operands subtracted from each other. The first operand is (3 + 5) and the second operand is 12.

This chapter will discuss most of the operators available to you in Perl . You'll find out about many operator types and how to determine their order of precedence. And, of course, you'll see many examples.

Precedence is very important in every computer language and Perl is no exception. The order of precedence indicates which operator should be evaluated first.

I like to think about operators in the same way I would give instructions to the driver of a car. I might say "turn left" or "turn right." These commands could be considered directional operators in the same way that + and mathematical operators that say "add this" or "subtract this." If I yell "stop" while the car is moving, on the other hand, it should supersede the other commands. This means that "stop" has precedence over "turn left" and "turn right." The "Order of Precedence" section later in this chapter will discuss precedence in more detail.

Operator Types

Table 4.1-The Perl Operator Types

Operator Types Number	Page or Chapter	Description
Arithmetic		These operators mirror those you learned in grade school. Addition, Subtraction, and multiplication are the bread and butter of most mathematical statements.
Assignment		These operators are used to assign a value to a variable. Algebra uses assignment operators. For example, in the statement X = 6, the equal sign is the assignment operator.
Binding		These operators are used during string comparisons and are explained in Chapter 10, "Regular Expressions."
Bitwise		These operators affect the individual bits that make up a value. For example, the value 3 is also 11 in binary notation or ((1 * 2) + 1). Each character in binary notation represents a bit which is smallest piece of a computer's memory that you can modify.
Comma	Chapter 6	The comma operator has two functions. It serves to separate array or list elements (see Chapter 2, "Numeric and String Literals") and it serves to separate expressions (see Chapter 6, "Statements").
File Test	Chapter 9	These operators are used to test for various conditions associated with files. You can test for file existence, file type, and file access rights among other things. See Chapter 9, "Using Files," for more information.
List	Chapter 5	List operators are funny things in Perl. They resemble function calls in other languages. List operators are discussed in Chapter 5, "Functions."
Logical	Chapter 13	These operators implement Boolean or true/false logic. In the sentence "If John has a fever AND John has clogged sinuses OR an earache AND John is NOT over 60 years old, then John has a cold," the AND, OR and NOT are acting as logical operators. The low precedence logical operators will be discussed separately in Chapter 13, "Handling Errors and Signals," on.
Numeric Relational		These operators allow you to test the relationship of one numeric variable to another. For example, is 5 GREATER THAN 12?
Postfix	Chapter 5	A member of this group of operators - (), [], {} - appears at the end of the affected objects. You've already seen them used in Chapter 3, "Variables" for arrays and associative arrays. The parentheses operators are also used for list operators as discussed in Chapter 5, "Functions."
Range		The range operator is used to create a range of elements in arrays. It can also be used in a scalar context.
Reference	Chapter 8	The reference operators are used to manipulate variables. For more information, see Chapter 8, "References."
String		The string concatenation operator is used to join two strings together. The string repetition operator is used to repeat a string.
String Relational		These operators allow you to test the relationship of one string variable to another. For example, is "abc" GREATER THAN "ABC"?
Ternary		The ternary operator is used to choose between two choices based on a given condition. For instance: If the park is within one mile, John can walk, otherwise he must drive.

The Binary Arithmetic Operators

Table 4.2-The Binary Arithmetic Operators

Operator	Description
op1 + op2	Addition
op1 - op2	Subtraction
op1 * op2	Multiplication
op1 ** op2	Exponentiation
op1 / op2	Division
op1 % op2	Modulus

Example: The Exponentiation Operator

The exponentiation operator is used to raise a number to a power. For instance, 2 ** 4 is equivalent to 2 * 2 * 2 * 2 which equals 16. You'll occasionally see a reference to exponentiation when the discussion turns to how efficient a given algorithm is but I've never needed it for my everyday programming tasks. In any case, here's a quick look at how it works.

This example shows how to raise the number 4 to the 3^rd power which is equivalent to 4 * 4 * 4 or 64.

Pseudocode

Assign $firstVar the value of 4. Raise 4 to the 3rd power using the exponentiation operator and assign the new value to $secondVar. Print $secondVar.

$firstVar = 4;
$secondVar = $firstVar ** 3;
print("$secondVar\n");

64

Example: The Modulus Operator

I've found the modulus operator to be useful when my programs need to run down a list and do something every few items. This example shows you how to do something every 10 items.

Pseudocode

Start a loop that begins with $index equal to zero. If the value of $index % 10 is equal to zero then the print statement will be executed. Print the value of $index followed by space. The program will increase the value of $index by one and then loop back to the start of the if statement.

Listing 4.1-04LST01.PL - How to Display a Message Every Ten Items

for ($index = 0; $index <= 100; $index++) { if ($index % 10 == 0) { print("$index "); } }

When this program is run, the output should look like the following:

0 10 20 30 40 50 60 70 80 90 100

The Unary Arithmetic Operators

Table 4.3-The Unary Arithmetic Operators

Operator	Description
Changing the sign of op1
+op1	Positive operand
-op1	Negative operand
Changing the value of op1 before usage
++op1	Pre-increment operand by one
--op1	Pre-decrement operand by one
Changing the value of op1 after usage
op1++	Post-increment operand by one
op1--	Post-decrement operand by one

Arithmetic operators start to get complicated when unary operators are introduced. Just between you and me, I didn't get the hang of negative numbers until someone said: "If you have five pieces of chocolate, and add negative two pieces..."

You might think that adding negative numbers is strange. Not so. I know that you will never write a mathematics statement like the following: 345 + -23. However, you might use 354 + $gasBill, where $gasBill represents a 23-dollar debit - in other words, a negative number.

Using the unary plus operator does nothing, and Perl ignores it. The unary negative operator, however, changes the meaning of a value from positive to negative or vice versa. For instance, if you had a variable called $firstVar equal to 34. Then printing -$firstVar would display -34.

The ++ and -- operators are examples of the Perl shorthand notation. If the ++ or -- operators appear in front of the operand, the operand is incremented or decremented before its value is used. If the ++ or -- operators appear after the operand, then the value of the operand is used and then the operand is incremented or decremented as required.

Example: The Pre-increment Operator

Pseudocode

Original Way The $numPages variable is assigned a value of 5. The $numPages variable is incremented by 1. The $numPages variable is printed. New Way The $numPages variable is assigned a value of 5. The $numPages variables is incremented using the pre-increment operator and then printed.

Listing 4.2-04LST02.PL - Using Pre-increment Operator

# Original Way $numPages = 5; $numPages = $numPages + 1; print($numPages, "\n"); # New Way $numPages = 5; print(++$numPages, "\n");

This program produces the following output:

6
6

Example: The Pre-Decrement Operator

Pseudocode

Original Way The $numPages variable is assigned a value of 5. The $numPages variable is decremented by 1. The $totalPages variable is assigned the value of $numPages + 5. The $numPages and $totalPages variables are printed. New Way The $numPages variable is assigned a value of 5. The $numPages variable is decremented and then $numPages + 5 is assigned to $totalPages. The $numPages and $totalPages variables are printed.

Listing 4.3-04LST03.PL - Using Pre-decrement Operator

# Original Way $numPages = 5; $numPages = $numPages - 1; $totalPages = $numPages + 5; print("$numPages $totalPages \n"); # New Way $numPages = 5; $totalPages = --$numPages + 5; print("$numPages $totalPages \n");

This program produces the following output:

4 9
4 9

Example: The Post-increment Operator

Pseudocode

Original Way The $numPages variable is assigned a value of 5. The $totalPages variable is assigned the value of $numPages. The $numPages variable is incremented by one. The $numPages and $totalPages variables are printed. New Way The $numPages variable is assigned a value of 5. The $totalPages variable is assigned the value of $numPages and then the $numPages variable is incremented. The $numPages and $totalPages variables are printed.

Listing 4.4-04LST04.PL - Using Post-increment Operator

# Original Way $numPages = 5; $totalPages = $numPages; $numPages = $numPages + 1; print("$numPages $totalPages \n"); # New Way $numPages = 5; $totalPages = $numPages++; print("$numPages $totalPages \n");

The program produces the following output:

6 5
6 5

Tip

The Perl programming language has many ways of achieving the same objective. You will become a more efficient programmer if you decide on one approach to incrementing/decrementing and use it consistently.

The Logical Operators

Table 4.4-The Logical Operators

Operator	Description
op1 && op2	Performs a logical AND of the two operands
op1 || op2	Performs a logical OR of the two operands.
!op1	Performs a logical NOT of the operand.

The concept of logical operators is simple. They allow a program make a decision based on multiple conditions. Each operand is considered a condition that can be evaluated to a true or false value. Then the value of the conditions are used to determine the overall value of the op1 operator op2 or !op1 grouping. The following examples demonstrate different ways that logical conditions can be used.

Example: The "AND" Operator (&&)

Table 4.5-The && Result Table

Op1	Op2	Op1 && Op2
0	0	0
1	0	0
0	1	0
1	1	1

Pseudocode

If the value of $firstVar is 10 AND the value of $secondVar is 9 then print the error message.

if ($firstVar == 10 && $secondVar == 9) {
    print("Error!");
};

Example: The "OR" Operator (||)

Table 4.6-The || Result Table

Op1	Op2	Op1 || Op2
0	0	0
1	0	1
0	1	1
1	1	1

Pseudocode

If the value of $firstVar is 9 OR the value of $firstVar is 10 then print the error message.

if ($firstVar == 9 || $firstVar == 10) {    print("Error!");
};

Caution

If the first operand of the || operator evaluates to true, the second operand will not be evaluated. This could be a source of bugs if you are not careful. For instance, in the following code fragment if ($firstVar++ || $secondVar++) { print("\n"); } variable $secondVar will not be incremented if $firstVar++ evaluates to true.

Note

You might be tempted to try the following if ($firstVar == (9 || 10)) { print("Error!"); }; to determine if $firstVar is equal to either 9 or 10. Don't do it. Perl doesn't work this way. First, the expression (9 || 10) will be evaluated to be equal to 9. And then, Perl will evaluate $firstVar == 9. The correct method for testing $firstVar is to explicitly state each sub-condition that needs to be met in order for the entire condition to return true. The correct way is: if ($firstVar == 9 || $firstVar == 10) { print("Error!"); };

Example: The "NOT" Operator (!)

Table 4.7-The ! Result Table

Op1	!Op1
0	1
1	0

Pseudocode

Assign a value of 10 to $firstVar. Negate $firstVar - !10 is equal to 0 - and assign the new value to $secondVar. If the $secondVar variable is equal to zero then print the string "zero."

$firstVar = 10;
$secondVar = !$firstVar;
if ($secondVar == 0) {
   print("zero\n");
};

zero

The Bitwise Operators

Table 4.8-The Bitwise Operators

Operator	Description
op1 & op2	The AND operator compares two bits and generates a result of 1 if both bits are 1; otherwise it returns 0.
op1 | op2	The OR operator compares two bits and generates a result of 1 if either or both bits are 1; otherwise it returns 0.
op1 ^ op2	The EXCLUSIVE-OR operator compares two bits and generates a result of 1 if the bits are complementary; otherwise it returns 0.
~op1	The COMPLEMENT operator is used to invert all of the bits of the operand. I've never found this useful, so we'll skip looking at an example of it.
op1 >> op2	The SHIFT RIGHT operator moves the bits to the right, discards the far right bit, and assigns the left-most bit a value of 0. Each move to right effectively divides op1 in half.
op1 << op2	The SHIFT LEFT operator moves the bits to the left, discards the far left bit, and assigns the rightmost bit a value of 0. Each move to the left effectively multiplies op1 by 2.

Note

Both operands associated with the bitwise operator must be integers.

Bitwise operators are used to change individual bits in an operand. A single byte of computer memory - when viewed as a 8 bits - can signify the true/false status of 8 flags because each bit can be used as a boolean variable that can hold one of two values: true or false. A flag variable is typically use to indicate the status of something. For instance, computer files can be marked as read-only. So you might have a $fReadOnly variable who job would be to hold the read-only status of a file. This variable is called a flag variable because when $fReadOnly has a true value it's equivalent to a football umpire throwing a flag. The variable says, "Whoa!, don't modify this file."

When you have more than one flag variable, if might be more efficient to use a single variable to indicate the value of more than one flag. The next example shows you how to do this.

Example: Using the &, |, and ^ Operators

Fig. 04.1 - The bit definition of a text attribute control variable.

If you assume that $textAttr is used control the text attributes, then you could set the italic attribute by setting $textAttr equal to 128 like this.

$textAttr = 128;

Now let's set both the italic and underline attributes on at the same time. The underline value is 16, which has a bit pattern of 00010000. You already know the value for italic is 128. So we call on the OR operator to combine the two values.

$textAttr = 128 | 16;

$textAttr = 10000000 | 00010000;

The next step might be to turn the italic attribute off. This is done with the EXLUSIVE-OR operator, like so:

$textAttr = $textAttr ^ 128;

Example: Using the >> and << Operators

This example will divide by 4 using the >> operator.

Pseudocode

Assign a value of 128 to the $firstVar variable. Shift the bits inside $firstVar two places to the right and assign the new value to $secondVar. Print the $secondVar variable.

$firstVar = 128;
$secondVar = $firstVar >> 2;
print("$secondVar\n");

32

The right-most bit of a value is lost when the bits are shifted right. You can see this in the next example.

This example will divide by 8 using the >> operator.

Pseudocode

Assign a value of 129 - a bit pattern of 10000001 - to $firstVar. Every odd value has the right-most bit set. Shift the bits inside $firstVar three places to the right and assign the new value to $secondVar. Print the $secondVar variable.

$firstVar = 129;
$secondVar = $firstVar >> 3;
print("$secondVar\n");

16

Here's a quick example using the << operator. We'll multiply 128 by 8.

Pseudocode

Assign a value of 128 to the $firstVar variable. Shift the bits inside $firstVar three places to the left and assign the new value to $secondVar. Print the $secondVar variable.

$firstVar = 128;
$secondVar = $firstVar << 3;
print $secondVar;

1024

The Numeric Relational Operators

Note

It is important to realize that the equality operator is a pair of equals sign and not just one. Quite a few bugs are introduced into programs because people forget this rule and use a single equals sign when testing conditions.

Table 4.9-The Numeric Relational Operators

Operator	Description
The Equality Operators
op1 == op2	This operator returns true if op1 is equal to op2. For example, 6 == 6 is true.
op1 != op2	This operator returns true if op1 is not equal to op2. For example, 6 != 7 is true.
The Comparison Operators
op1 < op2	This operator returns true if op1 is less than op2. For example, 6 < 7 is true.
op1 <= op2	This operator returns true if op1 is less than or equal to op2. For example, 7 <= 7 is true.
op1 > op2	This operator returns true if op1 is greater than op2. For example, 6 > 5 is true.
op1 >= op2	This operator returns true if op1 is greater than or equal to op2. For example, 7 >= 7 is true.
op1 <=> op2	This operator returns 1 if op1 is greater than op2, 0 if op1 equals op2, and -1 if op1 is less than op2.

You will see many examples of these operators when you read about controlling program flow in Chapter 7, "Control Statements." Therefore, I'll only show an example of the <=> comparison operator here.

Example: Using the <=> Operator

Tip

You may sometimes see the <=> operator called the spaceship operator because of the way that it looks.

Pseudocode

Set up three variables. Print the relationship of each variable to the variable $midVar.

$lowVar =  8;
$midVar = 10;
$hiVar  = 12;

print($lowVar <=> $midVar, "\n");
print($midVar <=> $midVar, "\n");
print($hiVar  <=> $midVar, "\n");

-1
0
1

The String Relational Operators

Table 4.10-The String Relational Operators

Operator	Description
The Equality Operators
op1 eq op2	This operator returns true if op1 is equal to op2. For example, "b" eq "b" is true.
op1 ne op2	This operator returns true if op1 is not equal to op2. For example, "b" ne "c" is true.
The Comparison Operators
op1 lt op2	This operator returns true if op1 is less than op2. For example, "b" lt "c" is true.
op1 le op2	This operator returns true if op1 is less than or equal to op2. For example, "b" le "b" is true.
op1 gt op2	This operator returns true if op1 is greater than op2. For example, "b" gt "a" is true.
op1 ge op2	This operator returns true if op1 is greater than or equal to op2. For example, "b" ge "b" is true.
op1 cmp op2	This operator returns 1 if op1 is greater than op2, 0 if op1 equals op2, and -1 if op1 is less than op2.

String values are compared using the ASCII values of each character in the strings. You will see examples of these operators when you read about control program flow in Chapter 7, "Control Statements." So, we'll only show an example of the cmp comparison operator here.

Example: Using the cmp Operator

Pseudocode

Set up three variables. Print the relationship of each variable to the variable $midVar.

$lowVar = "AAA";
$midVar = "BBB";
$hiVar  = "CCC";

print($lowVar cmp $midVar, "\n");
print($midVar cmp $midVar, "\n");
print($hiVar  cmp $midVar, "\n");

-1
0
1

$firstVar = "AA";
$secondVar = " A";
print($firstVar cmp $secondVar, "\n");

1

The Ternary Operator

CONDITION-PART ? TRUE-PART : FALSE-PART

if (CONDITION-PART) {
    TRUE-PART
} else {
    FALSE-PART
}

The value of the entire operation depends on the evaluation of the CONDITION-PART section of the statement. If the CONDITION-PART evaluates to true, then the TRUE-PART is the value of the entire operation. If the CONDITION-PART evaluates to false, then the FALSE-PART is the value of the entire operation.

Tip

The ternary operator is also referred to as the conditional operator by some references.

Example: Using the Ternary Operator to Assign Values

Pseudocode

If $firstVar is zero, then assign $secondVar a value of zero. Otherwise, assign $secondVar the value in the first element in the array @array.

$secondVar = ($firstVar == 0) ? 0 : $array[0];

Pseudocode

The CONDITION-PART evaluates to true so the $firstVar variable is incremented.

1 ? $firstVar++ : $secondVar++;

0 ? $firstVar++ : $secondVar++;

In this example, You get a chance to see how the language can be abused. When there are more than two actions to consider you can nest ternary operators inside each other. However, as you can see, the result is confusing code.

Pseudocode

Assign one of four values to $firstVar depending on the value of $temp.

$
firstVar = $temp == 0 ?
                $numFiles++ :
                ($temp == 1 ?
                    $numRecords++ :
                    ($temp == 3 ? $numBytes++ : $numErrors++));

If you'd like to see a really strange use of the ternary operator, take a look at this next example. It uses the ternary operator to determine which variable gets assigned a value.

$firstVar = 1;
$secondVar = 1;
$thirdVar = 1;

($thirdVar == 0 ? $firstVar : $secondVar) = 10;

print "$firstVar\n";
print "$secondVar\n";
print "$thirdVar\n";

1
10
1

if ($thirdVar ==0) {
    $firstVar = 10;
} else {
    $secondVar = 10;
}

Note

Some programmers might think that this use of the ternary operator is as bad as using it to control program flow. However, I like this ability because it gives you the ability to concisely determine which variable is the target of an assignment.

The Range Operator (..)

Example: Using the Range Operator

Pseudocode

Create an array with ten elements that include 1, 2, 3, 4, 5, 6, 7, 8, 9, and 10.

@array = (1..10);

Pseudocode

Create an array with ten elements that include A, B, C, D, E, F, G, H, I , and J.

@array = ("A".."J");

Pseudocode

Create an array that includes AAA, 1, 2, 3, 4, 5, A, B, C, D, and ZZZ.

@array = ("AAA", 1..5, "A".."D", "ZZZ");

Pseudocode

Create an array with ten elements that include the strings 01, 02, 03, 04, 05, 06, 07, 08, 09, and 10.

@array = ("01".."10");

Pseudocode

Assign a string literal to $firstVar. Create an array with ten elements that include the strings 01, 02, 03, 04, 05, 06, 07, 08, 09, and 10.

$firstVar = "10";
@array = ("01"..$firstVar);

You've already seen "A".."Z" which is pretty simple to understand. Perl counts down the alphabet until Z is reached.

Caution

The two ranges "A".."Z" and "a".."Z" are not identical. And the second range does not contain all lower-case letters and all upper-case letters. Instead, Perl creates an array that just contains the lower-case letters. Apparently, when Perl reaches the end of the alphabet - whether lower-case or upper-case - the incrementing stops.

What happens when a two-character string is used as an operand for the range operator? Let's find out.

Pseudocode

Create an array that includes the strings aa, ab, ac, ad, ae, and af.

@array = ("aa" .. "af");

Pseudocode

Create an array that includes the strings ay, az, ba, bb, bc, bd, be, and bf.

@array = ("ay" .. "bf");

Note

If the right-hand side of the range operator is less than the left-hand side, an empty array is created.

Errata Note

In the printed version of this book the previous note was incorrect.

Note

Mark Pettigrew sent me a email message to let me know what an empty array is only created when numbers are involved. For exampl, @array = (5...1) creates an ampty array. However, @array = ('bf'..'ay') actually creates an array with the elements bf, bg, bh ... zz. The array creation stops when the z character is reached.

The String Operators (. and x)

Example: Using the Concatenation Operator

Here is an example that shows Perl converting a number into a string.

Pseudocode

Assign a string value to $firstVar. The string will be three values concatenated into one string.

$firstVar = "This box can hold " . 55 . " items.";
print("$firstVar\n");

This box can hold 55 items.

You can also use variables as operands with the concatenation operator.

Pseudocode

Assign string values to $firstVar and $secondVar. Assign the concatenation of $firstVar and $secondVar to $thirdVar. Print $thirdVar.

$firstVar = "AAA";
$secondVar = "BBB";
$thirdVar = $firstVar . $secondVar;
print("$thirdVar\n");

AAABBB

Example: Using the Repetition Operator

Here is an example that how to repeat a string 7 times.

Pseudocode

Assign $firstVar the value of "1". Assign $secondVar the value of $firstVar repeated seven times. Print $secondVar.

$firstVar = "1";
$secondVar = $firstVar x 7;
print("$secondVar\n");

1111111

Pseudocode

Assign $firstVar the value of "11 ". Assign $secondVar the value of $firstVar repeated seven times. Print $secondVar.

$firstVar = "11 ";
$secondVar = $firstVar x 7;
print("$secondVar\n");

11 11 11 11 11 11 11

Pseudocode

Assign the elements "A" through "G" to @array. Get the number of elements in @array, convert that number to a string, repeat it twice and then assign the new string to $firstVar. Print the @array and $firstVar variables.

@array = ('A'..'G');
$firstVar = @array x 2;
print("@array\n");
print("$firstVar\n");

A B C D E F G
77

The Assignment Operators

Table 4.11 lists all of Perl's assignment operators. After reading the other sections in this chapter about the various operator types, you should be familiar with all of the operations described in the table.

Table 4.11-The Assignment Operators

Operator	Description
var = op1;	This operator assigns the value of op1 to var.
var += op1;	This operator assigns the value of var + op1 to var.
var -= op1;	This operator assigns the value of var - op1 to var.
var *= op1;	This operator assigns the value of var * op1 to var.
var /= op1;	This operator assigns the value of var / op1 to var.
var %= op1;	This operator assigns the value of var % op1 to var.
var .= op1;	This operator assigns the value of var . op1 to var.
var **= op1;	This operator assigns the value of var ** op1 to var.
var x= op1;	This operator assigns the value of var x op1 to var.
var <<= op1;	This operator assigns the value of var << op1 to var.
var >>= op1;	This operator assigns the value of var >> op1 to var.
var &= op1;	This operator assigns the value of var & op1 to var.
var |= op1;	This operator assigns the value of var | op1 to var.
var ||= op1;	This operator assigns the value of var || op1 to var. Note This assignment operator was erroneously left out of the printed edition of the book. Randal Schwartz was kind enough to point out this problem.
var ^= op1;	This operator assigns the value of var ^ op1 to var.

The examples in this section will not describe the different assignment operators. Their use is straightforward. However, when assigning values to arrays there are some special situations. The first is assigning values to array slices and the second is assign array elements to scalars. Let's start with array slices.

Example: Assignment Using Array Slices

You can use the assignment operator in conjunction with array slices to assign values to multiple array elements in one statement. If you have an array with 10 elements and you need to change elements 4 and 7 you can do so like this:

Pseudocode

Create an array with 11 elements. Assign values to elements 4 and 7. Print the array.

@array = (0..10);
@array[4, 7] = ("AA","BB");
print("@array\n");

0 1 2 3 AA 5 6 BB 8 9 10

You can look at the array slice assignment in the following way. The array on the left is the target and the array on the right is the source. So, the target array gets assigned the values in the source array.

There are a number of variations on the basic idea of using array slices in assignment statements. You can use scalar variables in place of the literals as operands for the range operator.

Pseudocode

Create an array with 11 elements. Assign values to elements 4 and 7. Print the array.

$firstVar = "AA";
@array = (0..10);
@array[4, 7] = ($firstVar, $firstVar);
print("@array\n");

0 1 2 3 AA 5 6 AA 8 9 10

Pseudocode

Create an array with 11 elements and an array with 2 elements. Assign values to elements 4 and 7 of the @array1 array. Print @array1.

@array1 = (0..10);
@array2 = ("AA", "BB");
@array1[4, 7] = @array2;
print("@array1\n");

0 1 2 3 AA 5 6 BB 8 9 10

Pseudocode

Create an array with 11 elements. Swap elements 4 and 7. Print the array.

@array = (0..10);
@array[4, 7] = @array[7, 4];
print "@array\n";

0 1 2 3 7 5 6 4 8 9 10

Pseudocode

Create an array with 11 elements. Assign the 23rd, 24th, and 25th elements from @array2 to @array1 as elements 1, 2, and 3. Print the array.

@array1 = (0..10);
@array2 = ("A".."Z");
@array1[1..3] = @array2[23..25];
print "@array1\n";

0 X Y Z 4 5 6 7 8 9 10

Fig. 04.2 - Assigning array Elements using an array slice and the range operator.

If you only need certain elements from an array, you can use the array slice to select and create a new array in one step.

Pseudocode

Create an array with 10 elements. Assign the 2nd, 4th, and 6th elements from @array2 to @array1 as elements 0, 1, and 2. Print the arrays.

@array1 = ("A".."J");
@array2 = @array1[2, 4, 6];
print("@array1\n");
print("@array2\n");

A B C D E F G H I J
C E G

Example: Assigning an Array to Scalar Variables

It's also useful when you want to make your code more readable. So that instead of referring to the 3^rd element of an array as $array[3], you can refer to the value as $town or whatever variable name you use.

In this next example, we'll take an array that holds an address and separate the elements into four scalar variables.

Pseudocode

Create an array with Tom Jones' address. Assign each element of the array to a separate scalar variable. Print the scalar variables.

@array = ("Tom Jones", "123 Harley Lane", "Birmingham", "AR");
($name, $street, $town, $state) = @array;
print("$name, $street, $town, $state\n");

Tom Jones, 123 Harley Lane, Birmingham, AR

@array = ("Tom Jones", "123 Harley Lane", "Birmingham", "AR");
$name   = $array[0];
$street = $array[1];
$town   = $array[2];
$state  = $array[3];
print("$name, $street, $town, $state\n");

Tip

You can also use the array slice and range operators with this type of assignment also.

Order of Precedence

Perl uses associativity to decide which operators and operators belong together. For instance, the unary minus operator has an associativity of right to left because it affects the operand immediately to its right.

Table 4.12-The Order of Precedence and Associativity for Perl Operators

Level	Operator	Description	Associativity
22	(), [], {}	Function Calls, Parentheses, Array subscripts	Left to right
21	>	infix dereference operator	Left to right
20	++, --	Auto increment, Auto decrement	None
19	**	Exponentiation	Right to left
18	!, ~, +, -, \	Logical not, bitwise not, unary plus, unary minus, reference	Right to left
17	=~, !~	Match, Not match - These operators are described in Chapter 10. Briefly, they tell Perl to do pattern matching, substitution or translation on a specific variable instead of the $_ special variable.	Left to right
16	*, /, % x	Multiply, Divide, Modulus, Repetition	Left to right
15	+, -, .	Add, Subtract, String concatenation	Left to right
14	<<, >>	Bitwise left shift, Bitwise right shift	Left to right
13		File test operators	None
12		Relational Operators	None
11		Equality Operators	None
10	&	Bitwise and	Left to right
9	|, ^	Bitwise or, Bitwise xor	Left to right
8	&&	Logical and	Left to right
7	||	Logical or	Left to right
6	..	Range operator	None
5	?:	Ternary or conditional operator	Right to left
4		Assignment Operators	Right to left
3	,	Comma operator	Left to right
2	not	Low precedence logical operators	Left to right
1	and	Low precedence logical operators	Left to right
0	or, xor	Low precedence logical operators	Left to right

Note

The printed version of this book listed the not, and, or, and xor operators at the same precedence level. Randal Schwartz was kind enough to point out this problem.

Operators that are not discussed in this chapter are discussed elsewhere in this book. Table 4.1, at the beginning of the chapter, points out where you can get more information on those operators. In addition, you can read about the low precedence logical operators in Chapter 13, "Handling Exceptions and Signals."

Example: Order of Precedence

First, an example using the ternary operator and various arithmetic operators.

Pseudocode

Assign values to $firstVar and $secondVar. Assign either a 1 or 0 to $thirdVar based on the evaluation of the condition 34 + $firstVar-- + $secondVar ? 1 : 0. Print $thirdVar.

$firstVar = 4;
$secondVar = 1;
$thirdVar = 34 + $firstVar-- + $secondVar ? 1 : 0;
print("$thirdVar\n");

1

Pseudocode

Assign values to $firstVar and $secondVar. Assign either a 1 or 0 to $thirdVar based on the evaluation of the condition 34 + $firstVar-- + ($secondVar ? 1 : 0). Print $thirdVar.

$firstVar = 4;
$secondVar = 1;
$thirdVar = 34 + $firstVar-- + ($secondVar ? 1 : 0);
print "$thirdVar\n";

39

Caution

Remember that these examples are contrived to show a point. I don't program in this manner. I recommend using parentheses to tell Perl exactly how you want your code to be evaluated. So I would normally do the following: $thirdVar = 34 + $firstVar + ($secondVar ? 1 : 0); $firstVar--; The decrementing of $firstVar has been pulled out the first line because using the post-decrement operator has no effect on the first line and make it harder to understand.

Here is a example of operator precedence using the exponentiation operator. This also shows you how to determine operator precedence on your own.

Pseudocode

Assign an expression to $firstVar. Assign an expression to $secondVar using parenthesis to indicate a preferred precedence order. Assign an expression to $thirdVar using parenthesis in a different manner to indicate a preferred precedence order. Print the variables.

$firstVar = -2 ** 4;
$secondVar = -(2 ** 4);
$thirdVar = (-2) ** 4;

print "$firstVar\n";
print "$secondVar\n";
print "$thirdVar\n";

-16
-16
16

Tip

If you always use parentheses to indicate how you want the operators to be evaluated, you'll never need to worry about operator precedence in your code.

Summary

You learned that operators are used to tell Perl what actions to perform. Some operators take precedence over others so that they and their operands will be evaluated first. An operand can be as simple as the number 10 or very complex - involving variables, literals, and other operators. This means that they are recursive in nature.

Perl has many different types of operators: arithmetic, assignment, binding, bitwise, comma, file test, list, logical, postfix, range, reference, relational (both numeric and sting), string, and ternary. Most of these operator types were discussed in this chapter, and the rest are scattered throughout the rest of the book. Table 4.1 lists the page numbers where more information can be found on those operators not covered in this chapter.

The bulk of the chapter talked about various types of operators. Starting with binary arithmetic operators, and then unary arithmetic operators. You were introduced to the pre- and post-increment and pre- and post-decrement operators. Next, came the logical operators and the bitwise operators. Sometimes, the bitwise shift operators are used when fast integer multiplication and division is needed.

Then, came numeric and string relational operators. Followed by the ternary operator. The ternary operator was used to show you what an lvalue is. An lvalue is the value on the left sign of an assignment operator. It must evaluate to some variable that Perl can use to hold a value.

The range operator was used to create sequential elements of an array, the concatenation operator was used to join two strings together, and the string repetition operator was used to repeat a string a given number of times.

Then you looked at the list of assignment operators, most of which were shortcuts to reduce typing and clarify the meaning of the assignment.

And finally, you saw a detailed list of Perl's operators and their order of precedence. Several examples were given to illustrate how precedence worked. My recommendation is to use parentheses to explicitly tell Perl how which order to evaluate operators.

The next chapter, "Functions," will look at how functions and list operators are the same thing. And you will be introduced to subroutines and parameters.

Review Questions

1. What are three arithmetic operators?

2. What does the x operator do?

3. What does it mean to pre-decrement a variable?

4. What is the value of 1 ^ 1?

5. What is the value of 1 << 3?

6. What is the ternary operator used for?

7. Can the x operator be used with arrays?

8. What is the precedence level of the range operator?

9. What is the value of 2 * 5 + 10?

10. What is the value of 65 >> 1?

11. What is the spaceship operator used for?

12. If an array were defined with ("fy".."gb"), what would its elements be?

Review Exercises

1. Assign a value to $firstVar using both division and subtraction.

2. Using the post-decrement operator, subtract one from $firstVar.

3. Write a program that assigns values to $firstVar and $secondVar and uses the >= operator to test their relationship to each other. Print the resulting value.

4. Use the **= assignment operator to assign a value to $firstVar.

5. Use the ternary operator to decide between to different value.

6. Write a program that assigns values to $firstVar and $secondVar and uses the <=> operator to test their relationship to each other. Print the resulting value.

7. Use the concatenation operator to join the following values together: "A" x 4 and "B" x 3.

8. Use the exponentiation operator to find the value of 2 to the 5th power.

9. Write an assignment statement that uses the && and || and ! operators.

10. Write a program that prints the value of the fifth bit from the right in a scalar variable.

11. Write a program that uses a bitwise assignment to set the fifth bit from the right in a scalar variable.

12. Write a program that shows the difference in operator precedence between the % operator and the && operator.