Perl CGI Happy Path: Flow Control

How to ask questions and vary program execution as a result of the answer.

Statement Blocks

• Control Structures are constructs used to control the flow of program execution.
• A control structure is generally associated with a statement block.
• A statement block is a sequence of statements, starting and ending with curly braces.
• A block of statements is allowed in place of any single statement (but the reverse is not generally true, e.g. no dangling else statements).
• The final semicolon in a block of statements is optional, allowing you to use sane C form, or confuse the heck out of everyone by using the pascal form.
• Example:
  

  { 
      some_statement; 
      some_statement; 
      some_statement; 
  } 
  

• In perl, truth is defined as follows:

  Table to Truth for Perl

  Element	Truth
  0, "0", or anything that computes to 0 or "0"	False
  undef, or anything that computes to undef	False
  "", or anything that computes to ""	False
  Everything Else	True
  "00" (string of two zeros)	True (it is not a single 0 after all)
  "0.0"	True (again, it is not a single 0 after all)

If and Unless

• The if statement evaluates a control expression for truth.
• If the control expression evaluates to true, the associated control structure is executed. Otherwise, the control structure is skipped.
• An elsif statement can specify an alternate control expression and control structure for evaluation and possible execution.
• An else statement can specify an alternate control structure for execution if no other control expressions were true.
• Example:
  

  if ( expression ) { 
      some_statement; 
      some_statement; 
      some_statement; 
  } elsif ( another_expression ) { 
      some_statement; 
      some_statement; 
  } elsif ( another_expression ) { 
      some_statement; 
      some_statement; 
  } else { 
      some_statement; 
      some_statement; 
  }
  

• The unless statement can be used if you wish to have only an else clause with no if clause. This can be helpfull for error messages or logging.
• Example:
  

  unless ( expression ) { 
      some_statement; 
      some_statement; 
      some_statement; 
  }
  

• The unless statement can also have an else.

While and Until

• The while statement continues to loop through a control structure for as long as a control expression evaluates true.
• Example:
  

  while ( expression ) { 
      some_statement; 
      some_statement; 
      some_statement; 
  } 
  

• Like the if versue unless instructions, there is a built in negation for while named until .
• until will continue to loop through the control structure until the control expression evaluates true.
• Example:
  

  until ( expression ) { 
      some_statement; 
      some_statement; 
      some_statement; 
  } 
  

Do While and Do Until

• The while / until statements may never execute the control strucuture at all if the control expression evaluates the right way the first time.
• There are times that you want to make sure the control structure executes at least one time, for example if the control expression is not valid until the control structure has performed some operation.
• You can move the while / until expression to the end of the control structure with the do operator.
• Just like in 'C' or 'C++', give the expression a terminating semicolon in this case.
• Example:
  

  do { 
      some_statement; 
      some_statement; 
      some_statement; 
  } while ( expression ); 
  

• Example:
  

  do { 
      some_statement; 
      some_statement; 
      some_statement; 
  } until ( expression ); 
  

For Loops

• The for loop allows you to specify a starting condition, an evaluation criteria, and an operation to be performed on each loop, all within a single line of code.
• The initial expression is set when the loop is initially entered.
• The test expression is evaluated at the top of each time through the loop. As soon as the expression is found to be false, the program skips the body of the loop and continues with the next line of code.
• The re initialization expression is executed on the second and all successive iterations through the loop. It is not executed the first time through the loop.
• Example:
  

  for ( initial_expression; test_expression; re-initialization_expr)
  {
      some_statement; 
      some_statement; 
      some_statement; 
  }
  

• Example:
  

  # Print the number 0 to 999 
  for ( $x=0; $x < 1000; $x++) 
  {
      print "$x\n"; 
  }
  

• You can put all sorts of goofy stuff in as your initial, test, and re-initialization expressions, and do all sorts of goofy stuff. The most common is leaving the initialization expression completely blank (if you already have a value for the variable and don't want to mess with it).

last

• The last statement gives you a backdoor to get out of a given loop.
• The last statement works for the for, foreach, while, until and naked blocks (implied while forever loops).
• The last statement does not work for the if and do while / until blocks.
• Example:
  

  # Keep getting user inputs until user enters quit.
  while ( $nextVar = <STDIN> )
  {
      chomp $nextVar;
      if ( $nextVar eq "quit" )
      {
          last;
      }
  
      print "You entered $nextVar\n";
  }
  

next

• The next statement allows you to skip past the rest of the enclosing block without killing the existing loop. Looping continues like normal, you have only skipped part of the enclosed block of instructions for this particular pass through the loop.
• The next statement works for the for, foreach, while, until and naked blocks (blocks that have put in manually that are not part of a larger block.
• The next statement does not work for the if and do while / until blocks.
• This is just like last .
• Example:
  

  # Sum all the even numbers entered 
  while ( $nextVar = <STDIN> ) 
  {
      chomp $nextVar; 
      if ( ! ($nextVar % 2) ) 
      { 
          next; 
      } 
      $theSum += $nextVar; 
  }
  

redo

• The redo statement allows you to skip back to the beginning of the current block, without revaluation of the control expression.
• The redo statement works for the for, foreach, while, until and naked blocks (blocks that have put in manually that are not part of a larger block.
• The redo statement does not work for the if and do while / until blocks.
• This is just like next .
• Example:
  

  # Create an infinite loop when first odd number is entered.
  while ( $nextVar = <STDIN> ) 
  {
      chomp $nextVar; 
      if ( ! ($nextVar % 2) ) 
      { 
          redo; 
      } 
      $theSum += $nextVar; 
  }
  

Labeled Blocks

• The next, last, and redo statements we just covered only jump one level of loop. If you have a loop in a loop, they default to operating on only one level at a time.
• It is possible with perl to give a block a name . This allows the loop modification statements above to be applied to any level of the loop.
• Note that when performing this operation in C, you must resort to a goto statement.
• To apply an operation to a particular loop level, just give the levels name to the loop modification statement.
• To name a loop level, just prepend the loop command with a label, followed by a colon (:).
• Example:
  

  # Create an infinite loop when first odd number is entered
  OUTERLOOP: while ( $nextVar = <STDIN> )
  {
      chomp $nextVar;
      if ( ! ($nextVar % 2) )
      {
          redo OUTERLOOP;
      }
      $theSum += $nextVar;
  }
  

Expression Modifiers

• The if, unless, while and until statements can be used with a single statement.
• They behave the same way as if they were used in the traditional block form, but in the case where only a single statement is to be iterated upon, this form can be more readable.

• Example:
  

  print "$Result is even\n" if ( ($Result % 2) == 0);
  print "$Counter\n" while ($Counter++ < 10);
  print "Backup Complete" unless ($Status > 0);
  print "Please enter \"QUIT\".\n" until (<STDIN> != "QUIT\n");
  

"&&" and "||" as Control Structures

• In keeping with the perl philosophy that no command can be too short (this was inherited from Unix), it is possible to use "&&" and "||" as control structures.
• if ($x < 10) { print "$x < 10\n"; } could also be written as ($x < 10) && (print "$x < 10\n");
• Likewise, unless ($x < 10) { print "$x > 10\n"; } could also be written as ($x < 10) || (print "$x > 10\n");
• This works because Perl uses short circuit evaluation... in other words, the second part of the expression is only executed if the first part of the expression meets minimum.
• In other words, if Perl can see that the expression is going to be false by looking at the first part of the expression only, it does not even bother to look at the second part of the expression, and it is not executed.