In the early Chapters of programming, many programmers used shift operators in place of multiplication and division wherever possible, because the shift operations were usually more efficient. (In fact, some compilers would optimize their code by converting multiplication and division to shifts.) ToChapter, it's usually best to use the shift operators when you are manipulating bits, and to use the multiplication and division operators when you're actually doing arithmetic. This will make your programs easier to understand.

Using the Assignment Operators

As you saw on Chapter 2, the assignment operator = associates, or assigns, a value to a variable. For example, the statement

$result = 42;

assigns the value 42 to the variable $result.

The = operator can appear more than once in a single statement. For example, in the statement

$value1 = $value2 = "a string";

the character string a string is assigned to both $value1 and $value2.

Perl also supports other assignment operators, each of which combines an assignment with another operation. For example, suppose that you want to add a value to a scalar variable and assign the result to the following variable:

$var = $var + 1;

Another way to write this is with the += assignment operator:

$var += 1;

This statement adds the value 1 to the existing value of $var.

An assignment operator exists for just about every bitwise operator and arithmetic operator that Perl supports. Table 4.3 lists the assignment operators supported in Perl.

Table 4.4 shows examples of the assignment operators, along with equivalent statements that use operators you've seen earlier.

Assignment Operators as Subexpressions

Any expression that contains an assignment operator can appear on the left side of another assignment operator. The following is an example:

($a = $b) += 3;

In cases such as this, the assignment enclosed in parentheses is performed first. This assignment is then treated as a separate subexpression whose value is the variable to which it is being assigned. For example, $a = $b has the value $a.

This means that the statement shown previously is equivalent to the following two statements:

$a = $b;

$a += 3;

Using Autoincrement and Autodecrement

So far, you've seen two ways to add 1 to a scalar variable:

$a = $a + 1;

$a += 1;

The first method uses the standard assignment operator = and the addition operator +, and the second method uses the addition assignment operator +=.

Perl also supports a third method of adding 1 to a scalar variable: the autoincrement operator, or ++. Here are some examples of the ++ operator in action:

$a++;

++$a;

$result = $a++;

$result2 = ++$a;

In each case, the ++ operator tells Perl to add 1 to the value stored in $a.

In some of the examples, the ++ is in front of the variable it is affecting, whereas in others the ++ follows the variable. If the ++ is first, the operation is a pre-increment operation; if the ++ follows, the operation is a post-increment operation.

The Autoincrement Operator Pre-Increment

To understand how the pre-increment operation works, first recall that you can use a single statement to assign a value to more than one variable, as follows:

$var1 = 43;

$var2 = $var1 += 1;

Here, the original value stored in $var1, 43, has 1 added to it. The result, 44, becomes the new value of $var1. This new value of 44 is then assigned to $var2.

The pre-increment operation works in the same way:

$var1 = 43;

$var2 = ++$var1;

The following code fragment tells Perl to add 1 to $var1 before doing anything else:

++$var1

As a result, $var1 becomes 44 before the value of $var1 is assigned to $var2. Therefore, $var2 is assigned 44.

The ++ operator is most frequently used in while statements. Listing 4.3 provides an example of a simple program that uses the ++ operator in a while statement.

Listing 4.3. A program that uses the pre-increment operation.

1:  #!/usr/local/bin/perl

2:  $value = 0;

3:  while (++$value <= 5) {

4:          print("value is now $value\n");

5:  }

6:  print("all done\n");

$ program4_3

value is now 1

value is now 2

value is now 3

value is now 4

value is now 5

all done

$

Note that the pre-increment operation enables you to add 1 to $value and test it all at the same time. This means that you no longer have to remember to add the following:

$value = $value + 1;

at the bottom of the while statement, which means that you are less likely to write a while statement that goes on forever.

Now see what happens when you change

while (++$value <= 5) {

to this:

while (++$value <= 0) {

and then run the program again. This time, you get the following:

all done

Because the ++ operator is in front of $value, 1 is added to $value before testing. This means that $value is not less than or equal to 0 when the while statement is executed for the first time; as a result, the code inside the while statement is never executed.

The Autoincrement Operator Post-Increment

The post-increment operator also adds 1 to the variable with which it is associated. However, its behavior is slightly different:

$var1 = 43;

$var2 = $var1++;

When the ++ operator appears after the variable, the ++ operator is performed after every- thing else is finished. This means that the original value of $var1, 43, is assigned to $var2. After this assignment is completed, 1 is added to $var1 and the new value of $var1 becomes 44.

To see how this works in while statements, examine Listing 4.4. Although it is similar to Listing 4.3, it performs a post-increment operation instead of a pre-increment operation.

Listing 4.4. A program that uses the post-increment operation.

1:  #!/usr/local/bin/perl

2:  $value = 0;

3:  while ($value++ <= 5) {

4:          print("value is now $value\n");

5:  }

6:  print("all done\n");

$ program4_4

value is now 1

value is now 2

value is now 3

value is now 4

value is now 5

value is now 6

all done

$

You are probably wondering why the output of Listing 4.4 contained the following line:

value is now 6

To figure out what happened, examine the value stored in $value each time the condition in the while statement is tested. Table 4.5 lists the contents of $value when the condition is tested, the result of the test, and $value immediately after the condition is tested (after the ++ operator is applied).

As you know, when the condition at the top of a while statement is true, the code inside the statement is executed, which in this case is

print("value is now $value\n");

This is why the line

value is now 6

appears-$value is 5 at the time the condition is tested, so the result is true.

To fix this problem, change the while condition to the following and run the program again:

while ($value < 5) {

This is the output you get from the changed program:

value is now 1

value is now 2

value is now 3

value is now 4

value is now 5

all done

Now, when $value is 5, the statement

while ($value++ < 5)

is false, and the code inside the while is not executed.

The Autodecrement Operator

As you've seen, the ++ operator adds 1 to the value of the variable it is associated with and can appear either before or after the variable. The -- operator, or autodecrement operator, works in the same way, but it subtracts 1 from the value of the variable it is associated with, as follows:

$a--;

--$a;

$result = $a--;

$result2 = --$a;

When the -- operator is in front of the variable, the operation is a pre-decrement operation, which means that 1 is subtracted from the variable before anything else happens.

$var1 = 56;

$var2 = --$var1;

This subtracts 1 from $var1 and assigns the result, 55, back to $var1. The value 55 is then assigned to $var2.

When the -- operator follows the variable, the operation is a post-decrement operation, which means that 1 is subtracted from the variable after everything else happens.

$var1 = 56;

$var2 = $var1--;

This assigns 56 to $var2 and then subtracts 1 from $var1, which means that $var1 now has the value 55.

DO be careful when you use the autoincrement and autodecrement operators. As you've seen, it's easy to get confused and tell your program to loop one too many times or one too few. I tend not to use these operators in while statements except in very simple cases, because they can get confusing. A better solution is to use the for statement, which you'll learn about on Chapter 8, "More Control Structures." DON'T use ++ or -- on both sides of a single variable, as in this statement, because it isn't allowed in Perl: ++$var1--; DON'T use autoincrement or autodecrement on a variable and then use the variable again in the same statement. $var1 = 10; $var2 = $var1 + ++$var1; Is $var2 now 20, 21, or 22? It's impossible to tell. Even different versions of Perl can produce different results!

Using Autoincrement With Strings

If a string value contains only alphabetic characters, the ++ operator can be used to "add one" to a string. In other words, the operator replaces the last character of the string with the next letter of the alphabet. The following is an example:

$stringvar = "abc";

$stringvar++;

Here, $stringvar now contains abd.

Note that this works only with ++, not --:

$stringvar = "abc";

$stringvar--;

The -- operator treats abc as a number, which means that it is equivalent to 0. The resulting value of $stringvar is, therefore, -1.

Auto-incrementing strings using ++ also works on capital letters.

$stringvar = "aBC";

$stringvar++;

The value stored in $stringvar is now aBD.

If the last letter of the string is z or Z, ++ converts this letter to a or A, and then "adds one" to the second-to-last character of the string:

$stringvar = "abz";

$stringvar++;          # $stringvar now contains "aca"

$stringvar = "AGZZZ";

$stringvar++;          # $stringvar now contains "AHAAA" 

This also works if the string contains one or more trailing digits.

$stringvar = "ab4";

$stringvar++;          # $stringvar now contains "ab5"

As in numeric operations, incrementing a string that ends in 9 carries over to the next character of the string. This works regardless of whether the next character is a digit or alphabetic character.

$stringvar = "bc999";

$stringvar++;          # $stringvar now contains "bd000" 

Incrementing string values using ++ works only if the variable has not already been converted to a number. $stringvar = "abc"; $stringvar += 5; $stringvar++; Here, the value of $stringvar is 6 because abc is converted to 0 by the += operator in the second statement. Also note that this does not work if the string value contains any character other than a letter or digit, or if a digit is located in the middle of the string. $stringvar = "ab*c"; $stringvar++; $stringvar = "ab5c"; $stringvar++; In both of these cases, the value stored in $stringvar is converted to its numeric equivalent, 0, before the ++ operation is performed. This means that $stringvar is assigned the value 1.

The String Concatenation and Repetition Operators

So far, the Perl operators you've seen operate only on integers. (To be exact, they can also operate on strings, but they convert the strings to integers first.) Perl also supports the following special operators that manipulate strings:

• The . operator, which concatenates (joins together) two strings
• The x operator, which repeats a string
• The .= operator, which combines concatenation and assignment

The String-Concatenation Operator

The string-concatenation operator, ., joins two strings together. For example, the following statement assigns the string potatohead to $newstring:

$newstring = "potato" . "head";

You can use the . operator with variables as in this example:

$string1 = "potato";

$string2 = "head";

$newstring = $string1 . $string2;

This also assigns potatohead to $newstring. Note that the values of $string1 and $string2 are not changed by the . operator: $string1 still has the value potato, and $string2 still has the value head.

The String-Repetition Operator

The string-repetition operator, x (literally the letter x), makes multiple copies of a string and joins the copies together, as shown in this example:

$newstring = "t" x 5;

This statement takes five copies of the string t and joins them together, producing the string ttttt. This string is then assigned to the variable $newstring.

You can use variables as operands for the x operator, if you like, as follows:

$copystring = "t";

$repeats = 5;

$newstring = $copystring x $repeats;

The only restriction is that the variable on the right of the x must contain an integer or a value that can be converted to an integer.

DO make sure you leave a space between the x operator and the values or variables on either side: $newstring = $oldstring x 5; # this is correct $newstring = $oldstringx 5; # incorrect $newstring = $oldstring x5; # also incorrect Normally, you don't need to put spaces between an operator and its operands. $x = $x + 1; # this is OK $x=$x+1; # this is also OK You need spaces around the x because the letter x can appear in variable names. (For example, $oldstringx is a perfectly valid variable name.)

Concatenation and Assignment

The .= operator combines the operations of string concatenation and assignment. For example, the following statements:

$a = "be";

$a .= "witched";            # $a is now "bewitched"

are equivalent to these statements:

$a = "be";

$a = $a . "witched";

You can use the .= operator to write a very simple program that reads multiple lines of input and joins them into a single string. This program is shown in Listing 4.5.

---

Listing 4.5. A program that reads input lines and concatenates them.

1:  #!/usr/local/bin/perl

2:  $resultstring = "";

3:  print("Enter your input - type an empty line to quit\n");

4:  $input = <STDIN>;

5:  chop ($input);

6:  while ($input ne "") {

7:          $resultstring .= $input;

8:          $input = <STDIN>;

9:          chop ($input);

10: }

11: print ("Here is the final string:\n");

12: print ("$resultstring\n");

---

$ program4_5

Enter your input - type an empty line to quit

this

is

a

test



Here is the final string:

thisisatest

$

As you can see from the output of Listing 4.5, the four input lines are joined and have become a single string.

Note that there is a much simpler way to do this in Perl: using the built-in function join(). You'll learn about join() on Chapter 5, "Lists and Array Variables."

Other Perl Operators

Perl also supports two other operators that do not fit into any of the preceding categories:

• The comma operator
• The conditional operator

The Comma Operator

The comma operator (,) is an operator borrowed from the C programming language. It guarantees that a particular part of an expression (the part before the ,) is evaluated first.

Here is an example of a simple statement that uses the , operator:

$var1 += 1, $var2 = $var1;

Because the , operator indicates that the left operand is to be performed first, 1 is added to $var1 before $var1 is assigned to $var2. In effect, the , operator breaks a statement into two separate statements, as follows:

$var1 += 1;

$var2 = $var1;

In fact, the only real reason to use the , operator is when two operations are so closely tied together that it is easier to understand the program if they appear as part of the same expression.

The comma operator is often used in conjunction with the = operator, as follows:

$val = 26;

$result = (++$val, $val + 5);

In this statement, the

++$val

operation is performed first, because it appears before the , operator. This adds 1 to $val, which means that $val now has the value 27. Then this new value of $val has 5 added to it, and the result, 32, is assigned to $result.

Note that the following expression is enclosed in parentheses:

++$val, $val + 5

This indicates that this set of operations is to be performed first. Had the parentheses not been present, the statement would have been

$result = ++$val, $val + 5;

In this case, everything before the comma would be performed first:

$result = ++$val

This means that $result would be assigned 27, not 32.

You'll learn more about parentheses and the order of operations later toChapter, in the section titled "The Order of Operations."

The Conditional Operator

The conditional operator also is borrowed from the C programming language. Unlike the other operators you've seen, the conditional operator requires three operands, as follows:

• A condition to test
• A value that is to be used when the test condition is true (evaluates to a nonzero value)
• A value that is to be used when the test condition is false (evaluates to zero)

The first two operands are separated by the character ?, and the second and third operands are separated by the character :.

Here is a simple example of an expression that uses the conditional operator:

$result = $var == 0 ? 14 : 7;

Here, the test condition is the expression

$var == 0

If this expression is true, the value 14 is assigned to $result. If it is false, the value 7 is assigned to $result.

As you can see, the conditional operator behaves just like the if and else statements. The expression

$result = $var == 0 ? 14 : 7;

is identical to the following:

if ($var == 0) {

        $result = 14;

} else {

        $result = 7;

}

The difference between the conditional operator and the if-else construct is that the conditional operator can appear in the middle of expressions. For example, the conditional operator can be used as another way to prevent division by 0, as follows:

$result = 43 + ($divisor == 0 ? 0 : $dividend / $divisor);

Here, $result is assigned the value 43 plus the result of $dividend divided by $divisor, unless $divisor is 0. If $divisor is 0, the result of the division is assumed to be 0, and $result is assigned 43.

Listing 4.6 is a simple program that reads from the standard input file and compares the input line with a predetermined password.

---

Listing 4.6. A very simple password checker.

1:  #!/usr/local/bin/perl

2:  print ("Enter the secret password:\n");

3:  $password = "bluejays";

4:  $inputline = <STDIN>;

5:  chop ($inputline);

6:  $outputline = $inputline eq $password ?

7:          "Yes, that is the correct password!\n" :

8:          "No, that is not the correct password.\n";

9:  print ($outputline);

---

$ program4_6

Enter the secret password:

orioles

No, that is not the correct password.

$

When you run program4_6 and type in a random password, you get the results shown in the Input-Output example.

The advantage of using the conditional operator here is that the assignment to $outputline occurs in only one place, and the statement is much more concise. If you use if and else, you need two assignments to $outputline and five lines, as follows:

if ($inputline eq $password) {

        $outputline = "Yes, that is the correct password!\n";

} else {

        $outputline = "No, that is not the correct password.\n");

}

Of course, the if and else statements are easier to use when things get more complex. Consider the following example:

if ($var1 == 47) {

        print("var1 is already 47\n");

        $is_fortyseven = 1;

} else {

        $var1 = 47;

        print("var1 set to 47\n");

        $is_fortyseven = 0;

}

You can write this using the conditional operator if you use the comma operator, as follows:

$var1 == 47 ? (print("var1 is already 47\n"), $is_fortyseven = 1) :

        ($var1 = 47, print("var1 set to 47\n"), $is_fortyseven = 0);

As you can see, this is difficult to understand. The basic rules are as follows:

• Use the conditional operator for very simple conditional statements.
• Use if and else for everything else.

Conditional Operators on the Left Side of Assignments

In Perl 5, you can use the conditional operator on the left side of an assignment. This enables you to assign a value to either of two variables, depending on the result of a conditional expression.

$condvar == 43 ? $var1 : $var2 = 14;

This statement checks whether $condvar has the value 43. If it does, $var1 is assigned 14. If it doesn't, $var2 is assigned 14.

Normally, you won't want to use conditional operators in this way because your code will become difficult to follow. Although the following code is a little less efficient, it performs the same task in a way that is easier to understand:

$condvar == 43 ? $var1 = 14 : $var2 = 14;

The Order of Operations

Perl, like all programming languages, has a clearly defined set of rules that determine which operations are to be performed first in a particular expression. The following three concepts help explain these rules:

• The concept of precedence
• The concept of associativity
• The ability to override precedence and associativity using parentheses

Precedence

In grade school, you learned that certain arithmetic operations always are performed before other ones. For example, multiplication and division always are performed before addition and subtraction.

4 + 5 * 3

Here, the multiplication is performed first, even though the addition is encountered first when the statement is read from left to right. Because multiplication always is performed first, it has higher precedence than addition.

Table 4.6 defines the precedence of the operators in Perl. The items at the top of the table have the highest precedence, and the items at the bottom have the lowest.

Table 4.6. Operator precedence.

Operator	Operation Performed
++, --	Autoincrement and autodecrement
-, ~, !	Operators with one operand
**	Exponentiation
=~, !~	Pattern-matching operators
*, /, %, x	Multiplication, division, remainder, repetition
+, -, .	Addition, subtraction, concatenation
<<, >>	Shifting operators
-e, -r, etc.	File-status operators
<, <=, >, >=, lt, le, gt, ge	Inequality-comparison operators
==, !=, <=>, eq, ne, cmp	Equality-comparison operators
&	Bitwise AND
|, ^	Bitwise OR and XOR
&&	Logical AND
||	Logical OR
..	List-range operator
? and :	Conditional operator (together)
=, +=, -=, *=,	Assignment operators
and so on
,	Comma operator
not	Low-precedence logical NOT
and	Low-precedence logical AND
or, xor	Low-precedence logical OR and XOR

Using this table, you can determine the order of operations in complicated expressions. For example:

$result = 11 * 2 + 6 ** 2 << 2;

To determine the order of operations in this expression, start at the top of Table 4.6 and work down. The first operator you see is **, which means that it is performed first, leaving

$result = 11 * 2 + 36 << 2;

The next operation you find in the table is the * operator. Performing the multiplication leaves the following:

$result = 22 + 36 << 2;

The + operator is next:

$result = 58 << 2;

Next up is the << operator:

$result = 232;

The = operator is last on the list and assigns 232 to $result.

You might have noticed that Table 4.6 contains some operators that you've not yet seen and which you'll learn about later:

• The list-range operator, defined on Chapter 5
• The file-status operators, defined on Chapter 6, "Reading from and Writing to Files"
• The pattern-matching operators, =~ and !~, defined on Chapter 7, "Pattern Matching"

Associativity

The rules of operator precedence enable you to determine which operation to perform first when an expression contains different operators. But what should you do when an expression contains two or more operators that have the same precedence?

In some cases, it doesn't matter what order you perform the operations in. For example:

$result = 4 + 5 + 3;

Here, $result gets 12 no matter which addition is performed first. However, for some operations the order of evaluation matters.

$result = 2 ** 3 ** 2;

If you perform the leftmost exponentiation first, $result is assigned 8 ** 2, or 64. If you perform the rightmost exponentiation first, $result is assigned 2 ** 9, or 512.

Because the order of operations is sometimes important, Perl defines the order in which operations of the same precedence are to be performed. Operations that are performed right-to-left (with the rightmost operation performed first) are said to be right associative. Operations that are performed left-to-right (with the leftmost operation performed first) are left associative.

Table 4.7 lists the associativity for each of the Perl operators. The operators are sorted according to precedence (in the same order as Table 4.6).

Table 4.7. Operator associativity.

Operator	Associativity
++, --	Not applicable
-, ~, !	Right-to-left
**	Right-to-left
=~, !~	Left-to-right
*, /, %, x	Left-to-right
+, -, .	Left-to-right
<<, >>	Left-to-right
-e, -r,	Not applicable and so on
<, <=, >, >=, lt, le, gt, ge	Left-to-right
==, !=, <=>, eq, ne, cmp	Left-to-right
&	Left-to-right
|, ^	Left-to-right
&&	Left-to-right
||	Left-to-right
..	Left-to-right
? and :	Right-to-left
=, +=, -=, *=,	Right-to-left
and so on
,	Left-to-right
not	Left-to-right
and	Left-to-right
or, xor	Left-to-right

From Table 4.7, you see that the exponentiation operator is right associative. This means that in the following:

$result = 2 ** 3 ** 2;

$result is assigned 512, because the rightmost ** operation is performed first.

Forcing Precedence Using Parentheses

Perl enables you to force the order of evaluation of operations in expressions. To do this, use parentheses as follows:

$result = 4 * (5 + 3);

In this statement, 5 is added to 3 and then multiplied by 4, yielding 32.

You can use as many sets of parentheses as you like:

$result = 4 ** (5 % (8 - 6));

Here, the result is 4:

• 8 - 6 is performed, leaving 4 ** (5 % 2)
• 5 % 2 is performed, leaving 4 ** 1
• 4 ** 1 is 4

DO use parentheses whenever you aren't sure whether a particular operation is to be evaluated first. For example, I don't know many programmers who remember that addition operators are evaluated before shifts: $result = 4 << 2 + 3; And virtually no one remembers that && has higher precedence than ||: if ($value == 0 || $value == 2 && $value2 == "hello") { print("my condition is true\n"); } You can make life a lot easier for people who read your code if you use parentheses when the order of evaluation is not obvious. For example: $result = 4 << (2 + 3); if ($value == 0 || ($value == 2 && $value2 == "hello")) { print("my condition is true\n"); } DO use multiple lines, extra spaces, and indentation to make complicated expressions easier to read. For example: if ($value == 0 || ($value == 2 && $value2 == "hello")) { Here, it's obvious that there are two main conditions to be tested and that one of them contains a pair of subconditions. DON'T leave out closing parentheses by mistake. $result = 4 + (2 << ($value / 2); # error This statement will be flagged as erroneous because you are missing a closing parenthesis. A handy way of checking whether you have enough parentheses in complicated expressions is to use this simple trick: Start at the left end of your expression. Starting from 0, add 1 for every left parenthesis you see. Subtract 1 for every closing parenthesis you see. If your final result is 0, you've got enough opening and closing parentheses. (This doesn't guarantee that you've put the parentheses in the right places, but at least you now know that you have enough of them.)

Summary

ToChapter you learned about the operators that Perl supports. Each operator requires one or more operands, which are the values on which the operator operates. A collection of operands and operators is known as an expression.

The operators you learned how to use are as follows:

• The arithmetic operators +, -, *, /, %, **, and unary negation
• The integer-comparison operators ==, !=, <, >, <=, >=, and <=>
• The string-comparison operators eq, ne, lt, gt, le, ge, and cmp
• The logical operators ||, &&, and !
• The bit-manipulation operators |, &, ^, ~, <<, and >>
• The assignment operators =, +=, -=, *=, /=, %=, **=, !=, &=, ^=, and .=
• The autoincrement operator ++
• The autodecrement operator --
• The string-concatenation operator .
• The string-repetition operator x
• The comma operator ,
• The conditional operator (? and : together)

You also learned about operator precedence and associativity, two concepts that tell you which operators in an expression usually are performed first. Operator precedence and associativity can be controlled by putting parentheses around the operations you want to perform first.

Q&A

Q:	Is there a limit on how large my expressions can be?
A:	Effectively, no. There is a limit, but it's so large that no one would possibly want to create an expression that long, because it would be impossible to read or understand.***It's easier to understand expressions if they are shorter.
Q:	Is it better to use += or ++ when adding 1 to a variable?
A:	It's best to use ++ when using a variable as a counter in a while statement (or in other loops, which you learn about on Chapter 8, "More Control Structures"). For other addition operations, you should use +=.
Q:	Why are some operators left associative and others right associative?
A:	Most operators are left associative, because we normally read from left to right. Assignment is right associative because it's easier to read. For instance: $var1 = $var2 = 5; If assignment happened to be left associative, $var1 would be assigned the old value of $var2, not 5. This would not be obvious to a casual reader of the program.Exponentiation is right associative because that's how exponentiation is performed in mathematics.Other operators that are right associative are easier to read from right to left.

Workshop

The Workshop provides quiz questions to help you solidify your understanding of the material covered and exercises to give you experience in using what you've learned. Try and understand the quiz and exercise answers before you go on to tomorrow's lesson.

Quiz

1. Define the following terms:
   a.    operator
   b.    operand
   c.    expression
   d.    precedence
   e.    associativity
2. What operations are performed by the following operators?
   a.   &&
   b.   &
   c.   ^
   d.   ne
   e.   .
3. What operators perform the following operations?
   a.    string-equality comparison
   b.    remainder
   c.    string duplication
   d.    bitwise OR
   e.    numeric greater-than-or-equal-to
4. What is the binary representation of the following numbers?
   a.   171
   b.   1105
   c.   0
5. What is the standard (base-10) representation of the following numbers?
   a.   01100100
   b.   00001111
   c.   01000001
6. What is the value of the following expressions?
   a.   17 * 2 ** 3 / 9 % 2 << 2
   b.   0 && (171567 * 98275 / 1174.5 ** 4)
   c.   1171 ^ 904
   d.   "abc" . "de" x 2

Exercises

1. Write a program that uses the << operator to print out the first 16 powers of 2.
2. Rewrite the following statement using the conditional operator:
   if ($var1 == 5 || $var2 == 7) {
   $result = $var1 * $var2 + 16.5;
   } else {
   print("condition is false\n");
   $result = 0;
   }
3. Rewrite the following expression using the if and else statements:
   $result = $var1 <= 26 ? ++$var2 : 0;
4. Write a program that reads two integers from standard input (one at a time), divides the first one by the second one, and prints out the quotient (the result) and the remainder.
5. Why might the following statement not assign the value 5.1 to $result?
   $result = 5.1 + 100005.2 - 100005.2;
6. Determine the order of operations in the following statement, and add parentheses to the statement to indicate this order:
   $result = $var1 * 2 << 5 + 3 || $var2 ** 3, $var3;
7. What value is assigned to $result by the following code?
   $var1 = 43;
   $var2 = 16;
   $result = ++$var2 == 17 ? $var1++ * 2 - 5 : ++$var1 * 3 - 11;
8. BUG BUSTER: Find and fix the bugs in the following program:
   #!/usr/local/bin/perl
   
   $num = <STDIN>;
   chop ($num);
   $x = "";
   $x += "hello";
   if ($x != "goodbye" | $x == "farewell") {
   $result = $num eq 0 ? 43;
   } else {
   $result = ++$num++;
   }
   print("the result is $result\n");

---

---