Note of Learning Perl--More Control Structures

More Control Structures
----------------------------

1. The until Control Structure
 The util loop runs until the conditional expression returns true. But it's really just a while loop in disguise, except that this one repeats as long as the conditional is false, rather than true. The conditional expression is evaluated before the first iteration, so this is still a zero-or-more-times loop.
 
2. The Naked Block Control Structure
 As a general guideline, all variables should be declared in the smallest scope available. If you need a variable for just a few lines of code, you can put those lines into a naked block and declare the variable inside that block. Of course, if we would need the value of either $n or $root later, we would need to declare them in a larger scope.
 
3. Autoincrement and Autodecrement
 A common use of these operators is in connection with a hash, to identify when an item has been seen before:

 my @people = qw{ fred barney bamm-bamm wilma dino barney betty pebbles };
 my %seen;
 
 foreach (@people) {
   print "I've seen you somewhere before, $_!\n"
     if $seen{$_}++;
 }
 
 When barney shows up for the first time, the value of $seen{$_}++ is false, since it's the value of $seen{$_}, which is $seen{"barney"}, which is undef. But that expression has the side effect of incrementing $seen{"barney"}. When barney shows up again, $seen{"barney"} is now a true value, so the message is printed.
 
4. The for Control Structure
 It turns out that, inside the Perl grammar, the keyword foreach is exactly equivalent to the keyword for. That is, any time Perl sees one of them, it's the same as if you had typed the other. Perl can tell which you meant by looking inside the parentheses. If you've got the two semicolons, it's a computed for loop (like we've just been talking about). If you don't have the semicolons, it's really a foreach loop.
 
5. Loop Controls
 1) The last operator immediately ends execution of the loop. (If you've used the "break" operator in C or a similar language, it's like that.) It's the "emergency exit" for loop blocks. When you hit last, the loop is done.
 2) The next operator: just like continue in Java.
 3) The third member of the loop control triad is redo. It says to go back to the top of the current loop block, without testing any conditional expression or advancing to the next iteration. The big difference between next and redo is that next will advance to the next iteration, but redo will redo the current iteration.
 
6. Control Structures Using Partial-Evaluation Operators
 1) Fortunately, you'll notice this only when the controlled expression has side effects, like altering a variable's value or causing some output. For example, suppose you ran across this line of code:
 ($a < $b) && ($a = $b);
 Right away, you should notice that the result of the logical AND isn't being assigned anywhere.(But don't forget to consider that it might be a return value, as the last expression in a subroutine.) Why not?
 If $a is really less than $b, the left side is true, so the right side will be evaluated, thereby doing the assignment. But if $a is not less than $b, the left side will be false, and thus the right side would be skipped. So that line of code would do essentially the same thing as this one, which is easier to understand:
 if ($a < $b) { $a = $b; }
 2) There is another way to write the logical AND and logical OR operators. You may wish to write them out as words: and and or. These word-operators have the same behaviors as the ones written with punctuation, but the words are much lower on the precedence chart. Since the words don't "stick" so tightly to the nearby parts of the expression, they may need fewer parentheses.