[Appendix A] A.3 Chapter 4, Control Structures

A.3 Chapter 4, Control Structures

Here's one way to do it:
```
print "What temperature is it? ";
chomp($temperature = <STDIN>);
if ($temperature > 72) {
  print "Too hot!\n";
} else {
  print "Too cold!\n";
}
```
The first line prompts you for the temperature. The second line accepts the temperature for input. The if statement on the final five lines selects one of two messages to print, depending on the value of $temperature.
Here's one way to do it:
```
print "What temperature is it? ";
chomp($temperature = <STDIN>);
if ($temperature > 75) {
  print "Too hot!\n";
} elsif ($temperature < 68) {
  print "Too cold!\n";
} else {
  print "Just right!\n";
}
```
Here, we've modified the program to include a three-way choice. First, the temperature is compared to 75, then to 68. Note that only one of the three choices will be executed each time through the program.
Here's one way to do it:
```
print "Enter a number (999 to quit): ";
chomp($n = <STDIN>);
while ($n != 999) {
  $sum += $n;
  print "Enter another number (999 to quit): ";
  chomp($n = <STDIN>);
}
print "the sum is $sum\n";
```
The first line prompts for the first number. The second line reads the number from the terminal. The while loop continues to execute as long as the number is not 999.
The += operator accumulates the numbers into the $sum variable. Note that the initial value of $sum is undef, which makes a nice value for an accumulator, because the first value added in will be effectively added to 0 (remember that undef used as a number is 0).
Within the loop, we must prompt for and receive another number, so that the test at the top of the loop is against a newly entered number.
When the loop is exited, the program prints the accumulated results.
Note that if you enter 999 right away, the value of $sum is not 0, but an empty string - the value of undef when used as a string. If you want to ensure that the program prints 0 in this case, you should initialize the value of $sum at the beginning of the program with $sum = 0.
Here's one way to do it:
```
print "Enter some strings, end with ^Z:\n";
@strings = <STDIN>;
while (@strings) {
  print pop @strings;
}
```
First, this program asks for the strings. These strings are saved in the array variable @strings, one per element.
The control expression of the while loop is @strings. The control expression is looking for a single value (true or false), and is therefore computing the expression in a scalar context. The name of an array (such as @strings) when used in a scalar context is the number of elements currently in the array. As long as the array is not empty, this number is non-zero, and therefore true. This is a very common Perl idiom for "do this while the array is non-empty."
The body of the loop prints a value, obtained by pop'ing off the rightmost element of the array. Thus, each time through the loop, the array is one element shorter, because that element has been printed.
You may have considered using subscripts for this problem. As we say, there's more than one way to do it. However, you'll rarely see subscripts in a true Perl Hacker's programs because a better way almost always exists.
Here's a way to do it without a list:
```
for ($number = 0; $number <= 32; $number++) {
  $square = $number * $number;
  printf "%5g %8g\n", $number, $square;
}
```
And here's how to do it with a list:
```
foreach $number (0..32) {
  $square = $number * $number;
  printf "%5g %8g\n", $number, $square;
}
```
These solutions both involve loops, using the for and foreach statements. The body of the loops are identical, because for both solutions, the value of $number proceeds from 0 to 32 on each iteration.
The first solution uses a traditional C-like for statement. The three expressions respectively: set $number to 0, test to see if $number is less than 32, and increment $number on each iteration.
The second solution uses a foreach statement. A list of 33 elements (0 to 32) is created, using the list contructor. The variable $number is then set to each element in turn.