If either of the two conditions is true, then the print command is run.

Example: The "NOT" Operator (!)

The ! operator is used to convert true values to false and false values to true. In other words, it inverts a value. Perl considers any non-zero value to be true-even string values. Table 4.7 shows the results of using the ! operator on true and false values.

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");

};

The program produces the following output:

zero

You could replace the 10 in the first line with "ten," 'ten,' or any non-zero, non-null value.

The Bitwise Operators

The bitwise operators, listed in Table 4.8, are similar to the logical operators, except that they work on a smaller scale.

Bitwise operators are used to change individual bits in an operand. A single byte of computer memory-when viewed as 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 used to indicate the status of something. For instance, computer files can be marked as read-only. So you might have a $fReadOnly variable whose 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 referee throwing a flag. The variable says, "Whoa! Don't modify this file."

When you have more than one flag variable, it 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

The first step to using bitwise operators to indicate more than one flag in a single variable is to define the meaning of the bits that you'd like to use. Figure 4.1 shows an example of 8 bits that could be used to control the attributes of text on a display.

Figure 4.1 : The bit definition of a text attribute control variable.

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

$textAttr = 128;

because the bit pattern of 128 is 10000000. The bit that is turned on corresponds to the italic position in $textAttr.

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.

or using the bit patterns (this is just an example-you can't do this in Perl)

If you look back at Table 4.8 and evaluate each bit, you will see that $textAttr gets assigned a value of 144 (or 10010000 as a bit pattern). This will set both italic and underline attributes on.

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

$textAttr = $textAttr ^ 128;

Example: Using the >> and << Operators

The bitwise shift operators are used to move all of the bits in the operand left or right a given number of times. They come in quite handy when you need to divide or multiply integer values.

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

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");

The program produces the following output:

32

Let's look at the bit patterns of the variables before and after the shift operation. First, $firstVar is assigned 128 or 10000000. Then, the value in $firstVar is shifted left by two places. So the new value is 00100000 or 32, which is assigned to $secondVar.

The rightmost 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.

Assign a value of 129-a bit pattern of 10000001-to $firstVar. Every odd value has the rightmost 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");

The program produces the following output:

16

Since the bit value of 16 is 00010000, you can tell that the rightmost bit has disappeared.

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

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

$firstVar = 128;

$secondVar = $firstVar << 3;

print $secondVar;

The program produces the following output:

1024

The value of 1024 is beyond the bounds of the 8 bits that the other examples used. This was done to show you that the number of bits available for your use is not limited to one byte. You are really limited by however many bytes Perl uses for one scalar variable-probably 4. You'll need to read the Perl documentation that came with the interpreter to determine how many bytes your scalar variables use.

The Numeric Relational Operators

The numeric relational operators, listed in Table 4.9, are used to test the relationship between two operands. You can see if one operand is equal to another, if one operand is greater than another, or if one operator is less than another.

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

Example: Using the <=> Operator

The number comparison operator is used to quickly tell the relationship between one operand and another. It is frequently used during sorting activities.

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");

The program produces the following output:

-1

0

1

The -1 indicates that $lowVar (8) is less than $midVar (10). The 0 indicates that $midVar is equal to itself. And the 1 indicates that $hiVar (12) is greater than $midVar (10).

The String Relational Operators

The string relational operators, listed in Table 4.10, are used to test the relationship between two operands. You can see if one operand is equal to another, if one operand is greater than another, or if one operator is less than another.

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. You may want to glance at Appendix E, "ASCII Table," to see all of the possible ASCII values.

Example: Using the cmp Operator

The string comparison operator acts exactly like the <=> operator except that it is designed to work with string operands. This example will compare the values of three different strings.

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");

The program produces the following output:

-1

0

1

Notice that even though strings are being compared, a numeric value is returned. You may be wondering what happens if the strings have spaces in them. Let's explore that for a moment.

$firstVar = "AA";

$secondVar = " A";

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

The program produces the following output:

1

which means that "AA" is greater than " A" according to the criteria used by the cmp operator.

The Ternary Operator

The ternary is actually a sequence of operators. The operator is used like this:

CONDITION-PART ? TRUE-PART : FALSE-PART

which is shorthand for the following statement:

if (CONDITION-PART) {

    TRUE-PART

} else {

    FALSE-PART

}

You can find more information about if statements in Chapter 7 "Control Statements."

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.

Example: Using the Ternary Operator to Assign Values

I frequently use the ternary operator to assign a value to a variable when it can take one of two values. This use of the operator is fairly straightforward.

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];

The ternary operator can also be used to control which code sections are performed. However, I recommend against this use because it makes the program harder to read. I believe that operators should affect variables, not program flow.

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

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

The CONDITION-PART evaluates to false so the $secondVar variable is incremented.

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

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

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";

The program produces the following output:

1

10

1

The line ($thirdVar == 0 ? $firstVar : $secondVar) = 10; is equivalent to the following control statement:

if ($thirdVar ==0) {

    $firstVar = 10;

} else {

    $secondVar = 10;

}

This use of the ternary operator works because Perl lets you use the results of evaluations as lvalues. An lvalue is anything that you can assign a value to. It's called an lvalue because it goes on the left side of an assignment operator.

The Range Operator (..)

The range operator was already introduced to you in Chapter 3 "Variables," when you read about arrays. I review its use here-in an array context-in a bit more detail.

Example: Using the Range Operator

When used with arrays, the range operator simplifies the process of creating arrays with contiguous sequences of numbers and letters. We'll start with an array of the numbers one through ten.

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

@array = (1..10);

You can also create an array of contiguous letters.

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

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

And, of course, you can have other things in the array definition besides the range operator.

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

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

You can use the range operator to create a list with zero-filled numbers.

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

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

And you can use variables as operands for the range operator.

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);

If you use strings of more than one character as operands, the range operator will increment the rightmost character by one and perform the appropriate carry operation when the number 9 or letter z is reached. You'll probably need to see some examples before this makes sense. I know that I had trouble figuring it out. So here goes.

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

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

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

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

This behaves as you'd expect, incrementing along the alphabet until the f letter is reached. However, if you change the first character of one of the operands, watch what happens.

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

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

When the second character is incremented to z, then the first character is incremented to b and the second character is set to a.

The String Operators (. and x)

Perl has two different string operators-the concatenation (.) operator and the repetition (x) operator. These operators make it easy to manipulate strings in certain ways. Let's start with the concatenation operator.

Example: Using the Concatenation Operator

The concatenation operator is used to join two strings together. If you have a numeric value as one of the two operands, Perl will quietly convert it to a string.

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

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");

The program produces the following output:

This box can hold 55 items.

The number 55 is automatically converted to a string and then combined with the other strings. Notice that the string literals have spaces in them so that when the final string is created, the number will be surrounded with spaces, making the sentence readable.

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

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");

The program produces the following output

AAABBB

Notice that Perl concatenates the strings together without adding any spaces or other separating characters. If you want a space between the string after they are concatenated, you must ensure that one of original strings has the space character-either at the end of the first string or the start of the second.

Example: Using the Repetition Operator

The repetition operator is used to repeat any string a given number of times. Like the concatenation operator, any numbers will be quietly converted to strings so that they can be repeated.

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

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");

The program produces the following output:

1111111

The string that gets repeated can be longer than one character.

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");

The program produces the following output:

11 11 11 11 11 11 11

You can also use the repetition operator on arrays or lists. However, the array gets evaluated in a scalar context so that the number of elements is returned. This number gets converted to a string and then repeated.

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");

This program produces the following output:

A B C D E F G

77

The Assignment Operators

The last type of operators that we'll look at are assignment operators. You've already used the basic assignment operator (=) to value variables in some of the examples earlier in this chapter. In addition, Perl has shortcut assignment operators that combine the basic assignment operator with another operator. For instance, instead of saying $firstVar = $firstVar + $secondVar you could say $firstVar += $secondVar. The advantage of the using shortcut operators-besides having less to type-is that your intentions regarding assignment are made clear.

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.

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 assigning array elements to scalars. Let's start with array slices.

Example: Assignment Using Array Slices

If you recall from Chapter 3 "Variables," array slices let you directly access multiple elements of an array using either the comma or range operators. For instance, the variable @array(10, 12) refers to both the tenth and the twelfth elements of the @array array.

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:

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

@array = (0..10);

@array[4, 7] = ("AA","BB");

print("@array\n");

This program produces the following output:

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.

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

$firstVar = "AA";

@array = (0..10);

@array[4, 7] = ($firstVar, $firstVar);

print("@array\n");

This program produces the following output:

0 1 2 3 AA 5 6 AA 8 9 10

And you can use array variables, also.

Create an array with 10 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");

This program produces the following output:

0 1 2 3 AA 5 6 BB 8 9 10

An array slice assignment is a quick and convenient way to swap two array elements from the same array.

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

@array = (0..10);

@array[4, 7] = @array[7, 4];

print "@array\n";

This program produces the following output:

0 1 2 3 7 5 6 4 8 9 10

Notice that the 4th element and the 7th element have swapped places. You can also use the range operator when using array slice assignment.

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

@array1 = (0..10);

@array2 = ("A".."Z");

@array1[1..3] = @array2[23..25];

print "@array1\n";

This program produces the following output:

0 X Y Z 4 5 6 7 8 9 10

Figure 4.2 shows a depiction of which array elements in @array2 are being assigned to which array elements in @array1.

Figure 4.2 : Assigning array elements using an array slice and the range operator.

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

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");

This program produces the following output:

A B C D E F G H I J

C E G

Example: Assigning an Array to Scalar Variables

At times, you may want to take array elements and assign them to scalar variables. The ability is especially useful inside functions and you'll read about that usage in Chapter 5 "Functions."

It's also useful when you want to make your code more readable. So, instead of referring to the 3rd 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.

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");

This program prints:

Tom Jones, 123 Harley Lane, Birmingham, AR

The first element of @array is assigned to the first scalar on the left side of the assignment operator. Because the scalars are surrounded by parentheses, Perl sees them as another list. If you couldn't do this type of multiple array element to multiple scalar assignment, you would have to do this:

@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");

I think that the first example is easier to understand, don't you? If the array has more elements than scalars, the extra elements are ignored. Conversely, if there are not enough elements, some of the scalar variables will have an undefined value.

Order of Precedence

We briefly touched on the order of precedence concept at the beginning of the chapter. Now that you are familiar with most of Perl's operators, we can explore the subject in more detail. Table 4.12 is an exhaustive list of operators and how they rank in terms of precedence-the higher the level, the higher their precedence. Operators at the same level have the same precedence and are evaluated from left to right. Otherwise, higher precedence levels are evaluated first.

Perl uses associativity to decide which 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.

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 Errors and Signals."

Example: Order of Precedence

While it is not possible to show examples of all the ramifications of operator precedence, we can look at one or two so that you can get a feel for the concept.

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

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

$firstVar = 4;

$secondVar = 1;

$thirdVar = 34 + $firstVar-- + $secondVar ? 1 : 0;

print("$thirdVar\n");

The program produces the following output:

1

The ternary operator has a precedence level of 5; every other operator has a higher precedence level and will be evaluated first.

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";

The program produces the following output:

39

This program results in a value of 39 for $thirdVar because the parentheses operators have a precedence level of 22. They serve to isolate regions of the statements and tell Perl to evaluate the stuff inside before evaluating the rest of the statement.

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

Assign an expression to $firstVar.
Assign an expression to $secondVar using parentheses to indicate a preferred precedence order.
Assign an expression to $thirdVar using parentheses 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";

The program produces the following output:

-16

-16

16

From this example, you can see the precedence level for exponentiation is higher than unary minus because the first and second variables are equal.

Summary

This chapter was pretty long and you've seen quite a few examples of how operators can be used. Let's review.

You learned that operators are used to telling 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 string), 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 chapters 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 are 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 side 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 were shortcuts to reduce typing and clarify the meaning of the assignment.

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 and in which order to evaluate operators.

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

Review Questions

Answers to Questions are in Appendix A.

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 two different values.
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.