Control structures allow you to
control the flow of your script—after all, if all a script could do was run from
start to finish, without any control over which portions of the script are run
and how many times, writing a program would be next to impossible.
PHP features a number of different
control structures—including some that, despite being redundant, significantly
simplify script development. You should be very familiar with all of them, as
they are one of the fundamental elements of the language’s structure.
Conditional
Structures
Conditional structures are used to
change the execution flow of a script based on one or more conditions. The most
basic of these structures is the if-then-else construct, which executes one of
two statements (or sets of statements enclosed in a code block) depending on
whether a condition evaluates to true or false:
if (expression1) {
} elseif (expression2)
{
// Note that the space
between else and if is optional
} else {
}
Here, if expression1 evaluates to true,
the code bl ock immediately following it is executed. Otherwise, the
interpreter attempts to execute the contents of the else portion of the
statement. Note that you chain together several if-then-else statements by using
the elseif construct instead o f a simple else (you can also use else if, which
is equivalent).
Naturally, if-then-else statements
can be nested:
if (expression1) {
if (expression2) {
// Code
} else {
// More code
}
} else {
if (expression3) {
// More core again.
}
}
A special ternary operator allows
you to embed an if-then-else statement inside an expression:
echo 10 == $x ? ’Yes’
: ’No’;
The code above would be equivalent
to the following:
if (10 == $x) {
echo ’Yes’;
} else {
echo ’No’;
}
As you can see, the former
expression is much more concise—and, if used properly, can make code much more
readable. However, you should think of this operation as nothing more than a
shortcut: used in excess, it can make your code difficult to understand and
compromise its functionality, particularly if you start nesting several of
these operations into each other.
The problem with if-then-else
statements is that they tend to get rather complicated when you need to check a
single expression against several different possible values. Imagine, for
example, the not-so-uncommon situation in which you have a series of related
if-then-else statements like the following:
$a = 0;
if ($a) {
// Evaluates to false
} elseif ($a == 0) {
// Evaluates to true
} else {
// Will only be
executed if no other conditions are met
}
There are several problems here.
First, you have to write a lot of code, which is difficult to maintain and
understand. Second, the value of $a must be evaluated every time an if
condition is encountered—which, in this case, is not a big problem, but could
be if you needed to evaluate a complex expression. To mitigate this problem, PHP
features the switch construct:
$a = 0;
switch ($a) { // In
this case, $a is the expression
case true: // Compare
to true
// Evaluates to false
break;
case 0: // Compare to
0
// Evaluates to true
break;
default:
// Will only be
executed if no other conditions are met
break;
}
A switch statement evaluates the
initial expression ($a in this case) only once, and then compares it against
the individual case values; if a match is found, it will continue to execute
code until it encounters a break statement. Note that the use of break is
required—or the interpreter will continue executing code even if it finds another
case. Finally, if none of the test cases match, the interpreter executes the
code block in the default block.
Iterative
Constructs
Iterative constructs make it
possible to execute the same portion of code multiple times. PHP has four of
these, although only two of them are necessary to the functioning of a
language.
The simplest iterative constructs
are the while() and do...while() lo ops; they allow you to perform a series of
operations until a condition evaluates to true:
$i = 0;
while ($i < 10) {
echo $i . PHP_EOL;
$i++;
}
$i = 0;
do {
echo $i . PHP_EOL;
$i++;
} while ($i < 10);
As you can see, these two types of
loop are very similar; the only significant difference is in when the condition
is checked to determine whether the code inside the construct should be
executed or not. In a while() loop, the check is per formed every time the
execution point enters the loop—this means that, if the condition is never true,
the code inside the loop will never be executed. In a do...while() loop, on the
other hand, the check takes place at the end of each iteration of the
loop—meaning that, even if the condition never evaluates to true, the contents
of the loop will be executed at least once.
The for and foreach constructs are
specialized looping mechanisms that can be used to essentially encapsulate a
while() loop in a slightly more readable form:
for ($i = 0; $i <
10;$i++) {
echo $i . PHP_EOL;
}
As you can see, the for declaration
contains three portions, separated by semicolons. The first one contains an
instruction (or series of instructions separated by a comma) that is executed
once before the loop has begun. The second one contains a condition that is
checked at the beginning o f every iteration the loop, and the third one an instruction
(or, again, a set of instructions separated by a comma) that is executed at the
end of every iteration. Therefore, the code above would be equivalent to
writing the following:
$i = 0;
while ($i < 10) {
echo $i . PHP_EOL;
$i++;
}
Similar to for is the foreach
construct, which allows you to loop through an array;
we discuss this construct in the
Arrays Section.
Breaking
and Continuing
The break keyword, which we
encountered briefly in the earlier section about the switch statement, can also
be used to immediately exit a loop; it takes an optional parameter, which
allows you to exit from multiple nested loops:
$i = 0;
while (true) {
if ($i == 10) {
break;
}
echo $i . PHP_EOL;
$i++;
}
for ($i = 0; $i <
10; $i++) {
for ($j = 0; $j <
3; $j++) {
if (($j + $i) % 5 == 0) {
break 2; // Exit from this loop and the next
one.
}
}
}
There are cases in which, rather
than terminating a loop, you simply want to skip over the remainder of an
iteration and immediately skip over to the next. This is done with the continue
statement—like with break, you can provide it an integer parameter to specify
the level of nesting to which the it applies. For example, the following code
will only output numbers between 0 and 3, and between 6 and 9:
for ($i = 0; $i <
10; $i++) {
if ($i > 3
&& $i < 6) {
continue;
}
echo $i . PHP_EOL;
}
0 Comment to " PHP: Control Structures "
Post a Comment