Vielleicht fragen Sie sich ja gerade, was denn die Bezeichnung "Kontrollstrukturen"schon wieder bedeuten soll. Die Antwort ist, dass Sie es mit einem sehr wichtigen Thema in der Programmierung zu tun haben.
Bisher wurde Code immer linear, also Befehl für Befehl, durchgeführt. Was ist aber, wenn ein Befehl nur durchgeführt werden soll, wenn eine bestimmte Bedingung erfüllt ist? Die Antwort liegt in einem bestimmten Befehl:

Der Befehl "if"

Durch den Befehl if können Sie festlegen, dass ein bestimmter Befehl nur unter einer bestimmten Bedingung durchgeführt wird. Wenn Sie zum Beispiel nur dann etwas ausgeben wollen, wen die Variable $x größer als 5 ist können Sie dazu folgenden Code heranziehen:

if ( $x > 5 )
    print('$x ist größer als 5');

In diesem Fall wird nur dann etwas ausgegeben, wenn die Variable $x größer als 5 ist.
Die allgemeine Syntax des Befehls if lautet:

if ( Bedingung )
    Befehl

Beachten Sie, dass die Zeile mit dem if nicht mit einem Strichpunkt enden darf. Aber was genau ist jetzt eine Bedingung?
Um es genau auszudrücken ist eine Bedingung ein spezieller Zahlenwert. Wenn dieser Zahlenwert ungleich null ist gilt die Bedingung als wahr, wenn sie gleich null ist als falsch. Da dies für die meisten Zwecke nicht ausreicht wurden so genannte Vergleichsoperatoren eingefügt, die Bedingungen darstellen. Für jeden dieser Operatoren wird vom Server dann entweder der Wert 0 für falsch oder der Wert 1 für wahr eingesetzt. Die Operatoren sind folgende:

Vergleichsoperatoren

Operator	Bedeutung	wahr:	falsch:
==	ist gleich	3 == 3	2 == 5
<	ist kleiner als	3 < 5	2 < 2; 2 < 0
>	ist größer als	3 > 2	5 > 5; 2 > 5
<=	ist kleiner als oder gleich	3 <= 5; 3 <= 3	2 <= 0
>=	ist größer als oder gleich	3 >= 2; 4 >= 4	1 >= 5;
!=	ist ungleich	3 != 5;	1 != 1

Damit dürfte das vorherige Beispiel erklärt sein.

Logische Verknüpfung von Bedingungen

Was ist aber, wenn zwei Bedingungen erfüllt seien müssen, also wenn zum Beispiel sowohl die Variable $x als auch die Variable $y größer als null seien müssen? Eine Möglichkeit wäre es, zwei if-Anweisungen folgendermaßen zu verschachteln:

if ( $x > 0 )
    if ( $y > 0 )
        print('$x und $y sind größer als 5');

Dieser Code ist aber unschön und unübersichtlich. Sie können aber stattdessen auch eine einleuchtendere Form verwenden:

if ( ($x > 0) And ($y > 0) )
    print('$x und $y sind größer als 5');

Bei diesem Code sollte sofort klar sein, was er bedeutet. And ist ein so genannter logischer Operator. Er gibt zurück, ob das, was links von ihm steht wahr ist und gleichzeitig auch das, was rechts von ihm steht, wahr ist. Folgende weitere Operatoren sind verfügbar:

Logische Operatoren

Operator	Bedeutung	wahr:	falsch:
And	und	1 And 1	1 And 0; 0 and 0
Or	oder	1 Or 1; 1 Or 0	0 Or 0
Xor	oder, aber nicht und	1 Xor 0; 0 Xor 1	1 Xor 1; 0 Xor 0
!	nicht	!(0)	!(1)

Der !-Operator bildet das Gegenteil von dem, was hinter ihm steht. Der Ausdruck !($x == $y) liefert dann 1, wenn $x und §y nicht gleich, also verschieden sind. Damit könnten Sie ebenso den Ausdruck $x != $y verwenden.

Mehrere Befehle von einer Bedingung abhängig machen

Bisher wurde immer nur ein Befehl von einer Bedingung abhängig gemacht. Wenn Sie mehrere Befehle unter ein- und derselben Bedingung durchführen wollen könnten Sie einfach mehrere IF-Strukturen mit der gleichen Bedingung verwenden:

if ($Alter < 18)
    print('Zu jung.');
if ($Alter < 18)
    $Zu_Jung = 1;
if ($Alter < 18)
    $Anzahl_Der_Probleme++;
    // In $Anzahl_Der_Probleme wird gezählt,
    // wie viele Fehler festgestellt wurden.
if ($Alter < 18)
    $Jahre_Zu_Alt = 18 - $Alter;

Dieser Code würde zwar funktionieren, hätte aber entscheidende Nachteile:

• Viel Tipparbeit, der Code wird dadurch fehleranfällig und unübersichtlich.
• Die Bedingung muss jedesmal neu geprüft werden, was bei komplizierten Bedingungen zu Performanceeinbußen führen würde.
• Wenn Sie die Bedingung ändern wollen müssen Sie sie in jeder if-Zeile ändern.
• Wenn der Code in der if-Struktur eine Variable in der Bedingung ändert kann dies die späteren Abfragen beeinträchtigen.

Sie könnten allerdings auch zuerst einer Variable das Ergebnis der Bedingung zuweisen und dann diese Variable abfragen:

$Bedingung = $Alter < 18
if ($Bedingung)
    print('Zu jung.');
if ($Bedingung)
    $Zu_Jung = 1;
if ($Bedingung)
    $Anzahl_Der_Probleme++;
    // In $Anzahl_Der_Probleme wird gezählt,
    // wie viele Fehler festgestellt wurden.
if ($Bedingung)
    $Jahre_Zu_Alt = 18 - $Alter;

Falls Sie jetzt die Bedingung ändern wollen müssen Sie nur noch die erste Zeile ändern.
Allerdings ist dies immer noch nicht die einfachste Methode. Sie können nämlich mehrere Befehle zusammenfassen, indem Sie sie in geschweifte Klammern ({ und }) setzen, sodass sie wie ein einziger behandelt werden. Das funktioniert ähnlich wie das Setzen runder Klammern in Rechenausdrücken.
Sie können dieses Wissen nutzen, um die komplizierte if-Bedingung von vorhin einfacher auszudrücken:

if ($Alter < 18)
{
    print('Zu jung.');
    $Zu_Jung = 1;
    $Anzahl_Der_Probleme++;
    // In $Anzahl_Der_Probleme wird gezählt,
    // wie viele Fehler festgestellt wurden.
    $Jahre_Zu_Alt = 18 - $Alter;
}

Diese Art des Codes bedeutet sehr wenig Tipparbeit und bietet auch eine gewisse Übersichtlichkeit, die durch die anderen Varianten nicht gewährleistet wurde.

Einrückung in Bedingungen

Es empfiehlt sich, abhängige Befehle leicht (zwei oder vier Leerzeichen) einzurücken, damit Sie auf einen Blick erkennen können, wo Kontrollblöcke beginnen und aufhören. Gewöhnen Sie sich einfach die hier gezeigten Formatierungen an, sie sind allgemein üblich.

Schleifen mit while

Was ist jetzt allerdings zu tun, wenn Sie Code mehrfach ausführen wollen?
In diesem Fall bietet sich die while-Schleife an. Die Allgemeine Syntax einer solchen Schleife ist folgende:

while (Bedingung)
    Befehl

Der Befehl wird solange ausgeführt, bis die Bedingung nicht mehr zutrifft. Falls die Bedingung von Anfang an nicht zutrifft wird der Befehl nicht ausgeführt. Da Schleifen selten nur einen Befehl enthalten, kann man auch hier mehrere Befehle mit geschweiften Klammern schachteln:

while (Bedingung)
{
    Befehl 1
    Befehl 2
    ...
}

Hier ein Beispiel:

$i = 0;
while ($i < 5)
{
    print ('$i ist jetzt gleich ' . $i . '.<br>');
    $i++;
}

Dieses Beispiel wird folgendes ausgeben:

$i ist jetzt gleich 0.
$i ist jetzt gleich 1.
$i ist jetzt gleich 2.
$i ist jetzt gleich 3.
$i ist jetzt gleich 4.

$i wird zu Beginn auf 0 gesetzt. anschließend wir überprüft, ob die Bedingung $i < 5 wahr ist, was der Fall ist. Nun wird $i ausgegeben und anschließend um eins erhäht. Die Bedingung wird wieder überprüft und, da sie immer noch wahr ist, der Code wieder ausgeführt. Ist allerdings $i gleich 5, wird die Schleife "verlassen".

Schleifen mit do-while

Eine andere Unterart der Schleife ist die do-while-Schleife. Die Syntax ist wie folgt:

do
    Befehl
while (Bedingung)

Der Unterschied der beiden Varianten ist, dass die while-Schleife null- oder mehrmals durchlaufen wird, die do-while-Schleife hingegen mindestens ein mal. Die Bedingung wird also erst nach dem ersten Durchlauf getestet. Somit wäre das obige Beispiel äquivalent zu folgendem Code:

Befehl
while (Bedingung)
    Befehl

Der eindeutige Vorteil der ersten Variante ist, dass der/die Befehl(e) nur einmal notiert werden muss/müssen. Obwohl die zweite Variante weniger bekannt ist, ist sie der zweiten vorzuziehen, da spätere Änderungen leichter vorgenommen werden können.

until- und do-until-Schleifen

Es gibt noch eine weitere Unterart der Schleifen. Der Unterschied besteht in der Negation der Bedingung, also wird dich Schleife ausgeführt, bis die Bedingung zutrifft. Die beiden folgenden Codeschnipsel sind also äquivalent:

until (Bedingung)
    Befehl

while (!(Bedingung))
    Befehl

Das gleiche gilt auch für die do-until-Schleife, sodass auch diese beiden Codeausschnitte die gleiche Wirkung haben:

do
    Befehl
until (Bedingung)

do
    Befehl
while (!(Bedingung))

Schleifen mit for

Da sehr oft eine bestimmte Art von Schleifen gebraucht wird, gibt es eine Sonderform der Schleifen. Die Syntax ist folgende:

for (Initialisierung; Bedingung; Reinitialisierung)
    Befehl

Die Initialisierung wird einmal vor dem Eingang in die Schleife durchgeführt, anschließend wird die Bedingung überprüft und, sofern diese wahr ist, der Befehl ausgeführt. Schließlich wird die Reinitialisierung durchgeführt und die Bedingung wieder überprüft. Damit könnten Sie auch folgendes schreiben:

Initialisierung;
while (Bedingung)
{
    Befehl;
    Reinitialisierung;
}

for-Schleifen werden häufig verwendet, um Arrays oder Dateien durchzugehen. Auf beide Fälle werde ich in späteren Kapiteln noch eingehen.

Mehrere Befehle in der (Re)initialisierung

Um mehrere Befehle in der Reinitialisierung oder in der Initialisierung zu verwenden müssen Sie diese statt durch Strichpunkte durch Kommata trennen:

for (Initialisierung1, Initialisierung2; Bedingung; Reinitialisierung1, Reinitialisierung2)
    Befehl

Die Bedingung darf natürlich nicht mit Kommata getrennt werden, da immer nur eine Bedingung existieren kann. Stattdessen können Sie mehrere Bedingungen mit logischen Operatoren verknüpfen (siehe weiter oben).

Den Schleifenverlauf beeinflussen

Es gibt zwei Befehle, die den Verlauf einer Schleife beeinflussen: break und continue.
break verlässt sofort die gesamte Schleife und führt den Code nach der Schleife aus:

$i = 0;
while ($i < 10)
{
    if ($i > 5)
        break;
    print($i . '<br>');
    $i++;
}

Die Ausgabe dieses Codeausschnitts ist wie folgt:

0
1
2
3
4
5

Da bereits bei einem Wert 6 von $i der Befehl break ausgeführt wird, wird die Schleife verlassen.

Zusammenfassung

• Dieses Kapitel ist neu.

Navigation

↑	Zur Übersicht
←	Zurück zu: PHP - Struktur von Code und Kommentare
→	Weiter zu: PHP - Kontrollstrukturen

---

---

---

---