Build Your Own DatabaseDriven Website Using PHP amp;amp; MySQL [Electronic resources] نسخه متنی

Control Structures

All the examples of PHP code that we've seen so far have been either
simple, one-statement scripts that output a string of text to the Web page,
or have been series of statements that were to be executed one after the other
in order. If you've ever written programs in any other languages (be they
JavaScript, C, or BASIC) you already know that practical programs are rarely
so simple.

PHP, just like any other programming language, provides facilities that
allow us to affect the flow of control in a script.
That is, the language contains special statements that permit you to deviate
from the one-after-another execution order that has dominated our examples
so far. Such statements are called control structures.
Don't get it? Don't worry! A few examples will illustrate perfectly.

The most basic, and most often-used, control structure is the if-else
statement. Here's what it looks like:

if ( condition ) {
// Statement(s) to be executed if
// condition is true.
} else {
// (Optional) Statement(s) to be
// executed if condition is false.
}

This control structure lets us tell PHP to execute one set of statements
or another, depending on whether some condition is true or false. If you'll
indulge my vanity for a moment, here's an example that shows a twist on the welcome1.php file
we created earlier:

$name = $_REQUEST['name'];
if ( $name == 'Kevin' ) {
echo( 'Welcome, oh glorious leader!' );
} else {
echo( "Welcome, $name!" );
}

Now, if the name variable passed to the page has
a value of Kevin, a special message will be displayed.
Otherwise, the normal message will be displayed and will contain the name
that the user entered.

As indicated in the code structure above, the else clause (that part of the if-else statement that says
what to do if the condition is false) is optional. Let's say you wanted to
display the special message above only if the appropriate name was entered,
but otherwise, you didn't want to display any message. Here's how the code
would look:

$name = $_REQUEST['name'];
if ( $name == 'Kevin' ) {
echo( 'Welcome, oh glorious leader!' );
}

The == used in the condition above is the PHP equal-to
operator that's used to compare two values
to see whether they're equal.

Conditions can be more complex than a single comparison for equality.
Recall that we modified welcome1.php to take a first
and last name. If we wanted to display a special message only for a particular
person, we'd have to check the values of both names (welcome6.php):

$firstname = $_REQUEST['firstname'];
$lastname = $_REQUEST['lastname'];
if ( $firstname == 'Kevin' and $lastname == 'Yank' ) {
echo( 'Welcome, oh glorious leader!' );
} else {
echo( "Welcome to my Website, $firstname $lastname!" );
}

This condition will be true if and only if $firstname has
a value of Kevin and $lastname has a
value of Yank. The word and in the above
condition makes the whole condition true only if both of the comparisons evaluate
to true. Another such operator is or, which makes the whole condition true if one or both of two simple
conditions are true. If you're more familiar with the JavaScript or C forms
of these operators (&& and || for and and or respectively),
they work in PHP as well.

We'll look at more complicated comparisons as the need arises. For the
time being, a general familiarity with the if-else statement
is sufficient.

Another often-used PHP control structure is the while loop. Where the if-else statement
allowed us to choose whether or not to execute a set of statements depending
on some condition, the while loop allows us to use a condition
to determine how many times we'll execute repeatedly a set of statements.
Here's what a while loop looks like:

while ( condition ) {
// statement(s) to execute over
// and over as long as condition
// remains true
}

The while loop works very similarly to an if-else statement
without an else clause. The difference arises when the
condition is true and the statement(s) are executed. Instead of continuing
the execution with the statement that follows the closing brace (}),
the condition is checked again. If the condition is still true, then the statement(s)
are executed a second time, and a third, and will continue to be executed
as long as the condition remains true. The first time the condition evaluates
false (whether it's the first time it's checked, or the one-hundred-and-first),
execution jumps immediately to the next statement following the while loop,
after the closing brace.

Loops like these come in handy whenever you're working with long lists
of things (such as jokes stored in a database... hint-hint!), but for now
we'll illustrate with a trivial example: counting to ten. This script is available
as count10.php in the code archive.

$count = 1;
while ($count <= 10) {
echo( "$count " );
$count++;
}

It looks a bit frightening, I know, but let me talk you through it line
by line. The first line creates a variable called $count and
assigns it a value of 1. The second line is the start of a while loop,
the condition for which is that the value of $count is
less than or equal (<=) to 10. The third and fourth
lines make up the body of the while loop, and will be executed
over and over, as long as that condition holds true. The third line simply
outputs the value of $count followed by a space. The fourth
line adds one to the value of $count ($count++ is
a short cut for $count = $count + 1—both will work).

So here's what happens when this piece of code is executed. The first
time the condition is checked, the value of $count is 1,
so the condition is definitely true. The value of $count (1)
is output, and $count is given a new value of 2. The condition
is still true the second time it is checked, so the value (2) is output and
a new value (3) is assigned. This process continues, outputting the values
3, 4, 5, 6, 7, 8, 9, and 10. Finally, $count is given a
value of 11, and the condition is false, which ends the loop. The net result
of the code is to output the string "1 2 3 4 5 6 7 8 9 10 ".

The condition in this example used a new operator: <= (less
than or equal). Other numerical comparison operators of this
type include >= (greater than or equal), < (less
than), > (greater
than), and != (not
equal). That last one also works when comparing
text strings, by the way.

Another type of loop that is designed specifically to
handle examples like that above, where we are counting through a series of
values until some condition is met, is called a for loop. Here's what they
look like:

for ( initialize; condition; update ) {
// statement(s) to execute over
// and over as long as condition
// remains true after each update
}

Here's what the above while loop example looks like
when implemented as a for loop:

for ($count = 1; $count <= 10; $count++) {
echo( "$count " );
}

As you can see, the statements that initialize and increment the $count variable
join the condition on the first line of the for loop. Although
the code is a little harder to read at first glance, having everything to
do with controlling the loop in the same place actually makes it easier to
understand once you're used to the syntax. Many of the examples in this book
will use for loops, so you'll have plenty of opportunity
to practice reading them.