# Programmsteuerung

Willst Du den Charakter eines Menschen erkennen, so gib ihm Macht.
– Abraham Lincoln, Präsident der USA (1861–65)

# if-Bedingung

Mit einer if-Bedingung können Sie die Ausführung von Quellcode von einer Bedingung abhängig machen.

if([Ausdruck])  
{  
  [Anweisungsblock]  
}

Ist das Ergebnis des Ausdrucks TRUE, werden die in den geschweiften Klammern notierten Anweisungen ausgeführt.

if($passwort == "geheim")  
{  
  echo "Passwort korrekt!";  
}

Der Anweisungsblock wird nur dann ausgeführt, wenn die Zeichenkette, die in der Variablen $passwort gespeichert ist, der Zeichenkette geheim entspricht.

Soll nach einer Bedingungsprüfung mit if nur eine einzelne Anweisung ausgeführt werden, müssen Sie die geschweiften Klammern nicht explizit notieren. Die Anweisung könnte also auch folgendermaßen aussehen:

if($passwort == "geheim") echo "Passwort korrekt!";

Dies ist aber nur erlaubt, da lediglich eine Anweisung ausgeführt wird. Bei mehreren auszuführenden Anweisungen müssen Sie die geschweiften Klammern setzen.

Um auch den Fall behandeln zu können, bei dem das Ergebnis des Ausdrucks FALSE ist, müssen Sie nach dem Anweisungsblock else und einen zweiten Anweisungsblock notieren. Die geschweiften Klammern sind in diesem Fall Pflicht.

if([Ausdruck])  
{  
  [if-Anweisungsblock]  
}  
else  
{  
  [else-Anweisungsblock]  
}

Ist also das Ergebnis des Ausdrucks TRUE, wird der if-Anweisungsblock und bei FALSE der else-Anweisungsblock ausgeführt.

if($passwort == "geheim")  
{  
  echo "Passwort korrekt!";  
}  
else  
{  
  echo "Passwort NICHT korrekt!";  
}

Gelegentlich kann es auch erforderlich sein, bei einem FALSE-Ergebnis des Ausdrucks einen zweiten Ausdruck zu überprüfen. In diesem Fall wird elseif verwendet.

if([Ausdruck1])  
{  
  [if-Anweisungsblock]  
}  
elseif([Ausdruck2])  
{  
  [elseif-Anweisungsblock]  
}  
...

Nur wenn das Ergebnis von Ausdruck1 FALSE und das Ergebnis von Ausdruck2 TRUE ist, wird der elsif-Anweisungsblock ausgeführt. Auf diese Art und Weise lässt sich eine if-Bedingung beliebig erweitern. Auch die Verwendung von else ist dann erlaubt, jedoch erst zum Schluss des gesamten Konstrukts.

if($a > 0) {  
  echo "\$a ist größer als 0";  
} elseif($a == 0) {  
  echo "\$a ist gleich 0";  
} else {  
  echo "\$a ist kleiner als 0";  
}

# do…while-Schleife

Die do...while-Schleife gehört zur Gruppe der nachprüfenden Schleifen, was bedeutet, dass eine do...while-Schleife immer mindestens einmal durchlaufen wird.

do  
{  
  [Anweisungsblock]  
} while([Ausdruck]);

Die do...while-Schleife wird so lange durchlaufen, wie das Ergebnis des Ausdrucks TRUE ist. Sobald das Ergebnis FALSE ist, wird die Schleife beendet und kein weiterer Durchlauf gestartet.

$i = 0;  
do  
{  
  $i++;  
  echo "Hallo Welt!<br>\n";  
} while($i < 10);

Diese Schleife gibt so lange die Zeichenkette Hallo Welt! im Browser aus, wie $i kleiner als 10 ist – somit also 10-mal.

Ein typisches Beispiel für eine Endlosschleife ist folgendes Konstrukt:

do  
{  
  echo "abc";  
} while(1);

Das Ergebnis des Ausdrucks ist immer TRUE, da 1 immer 1 ist. Aus diesem Grund wird die Schleife so lange die Zeichenkette abc ausgeben, bis der Ablauf des PHP-Scripts durch einen externen Einfluss unterbrochen wird. Alternativ ließe sich auch die Funktion break verwenden, die einen Schleifenabbruch ermöglicht.

$i = 0;  
do  
{  
  $i++;  
  echo "abc";  
  if($i > 10) break;  
} while(1);

# while-Schleife

Eine while-Schleife ist die einfachste Form von vorprüfenden Schleifen.

while([Ausdruck])  
{  
  [Anweisungsblock]  
}

Bevor die Schleife überhaupt durchlaufen wird, wird der Ausdruck überprüft. Ist das Ergebnis TRUE, wird die Schleife so lange ausgeführt, bis das Ergebnis des Ausdrucks FALSE lautet.

$i = 0;  
while($i <= 10)  
{  
  $i++;  
  echo "$i<br>\n";  
}

Diese Schleife gibt die Zahlen von 1 bis 10 im Browser aus. Solange $i also kleiner oder gleich 10 ist, wird der Anweisungsblock der Schleife durchlaufen. In diesem Anweisungsblock wird $i um 1 inkrementiert und anschließend ausgegeben.

# for-Schleife

Die for-Schleife ist eine der am häufigsten verwendeten Schleifen in Programmiersprachen. Der Grund ist die einfache Notation bei hoher Flexibilität. Zu Beginn können Sie eine Zählvariable, eine Ausführungsbedingung und eine Anweisung notieren, die bei jedem Schleifendurchlauf ausgeführt wird.

for([Ausdruck1]; [Ausdruck2]; [Ausdruck3])  
{  
  [Anweisungsblock]  
}

Für Ausdruck1 können Sie eine beliebige Bedingung notieren, die vor dem allerersten Schleifendurchlauf überprüft wird. In der Regel wird an dieser Stelle eine Variable notiert und ihr ein Wert zugewiesen.

Statt Ausdruck2 können Sie eine Bedingung notieren, die vor jedem Schleifendurchlauf überprüft wird. Ist das Ergebnis der Bedingung TRUE, wird die Schleife erneut durchlaufen. Bei FALSE wird die Schleife beendet. Hier wird in der Regel eine Bedingung in Bezug auf die in Ausdruck1 definierte Variable notiert.

Eine Anweisung, die bei jedem Schleifendurchlauf ausgeführt werden soll, notieren Sie anstelle von Ausdruck3. Dies ist meistens eine Anweisung, die die Variable aus Ausdruck1 inkrementiert oder dekrementiert.

for($i=0; $i<10; $i++}  
{  
  echo "$i<br>";  
}

Diese Schleife gibt die Zahlen von 0 bis 9 im Browser aus. Somit wird die Schleife also genau 10-mal durchlaufen.

Eine kürzere Variante ist folgende:

for($i=0; $i<10; echo "$i<br>", $i++);

Auch diese Schleife gibt die Zahlen von 0 bis 9 im Browser aus. Jedoch werden sowohl die echo-Anweisung als auch die Anweisung zum Inkrementieren von $i als dritter Ausdruck notiert.

# foreach-Schleife

Wie in Perl gibt es auch in PHP eine foreach-Schleife, mit der Sie über die Elemente eines Arrays traversieren können. Nur die Schreibweise unterscheidet sich von derjenigen in Perl, da in PHP Listen und Hashes bekanntermaßen unter den Typ Array fallen.

Die Syntax lautet:

foreach($array as  $value)  
{  
  [Anweisungsblock]  
}

Bei einfachen Arrays wird die oben dargestellte Syntax verwendet. Wenn Sie aber ein assoziatives Array verwenden, lautet die Schreibweise folgendermaßen:

foreach($array as $key =>  $value)  
{  
  [Anweisungsblock]  
}

Im ersten Syntax-Beispiel steht der Wert des gerade aktuellen Elements in der Variablen $value, im zweiten steht der Schlüssel des Arrays in der Variablen $key und der Wert in $value zur Verfügung. Wie Sie nun die Variablen im Einzelnen genau nennen, das bleibt Ihnen überlassen. Im Anweisungsblock können Sie dann mehrere Anweisungen notieren. Anstelle von $array müssen Sie natürlich den richtigen Bezeichner des Arrays notieren, das Sie abarbeiten möchten.

$zahlen = Array(1,2,3,4,5,6);  
foreach($zahlen as $zahl)  
{  
  echo "$zahl<br>\n";  
}

Dieses Beispiel würde nun über alle Elemente des Arrays $zahlen traversieren und den Wert des gerade aktuellen Elements in der Variablen $zahl speichern. Anschließend wird $zahl im Browser ausgegeben.

$laender = Array("DE" => "Deutschland",  
                 "FR" => "Frankreich",  
                 "ES" => "Spanien",  
                 "CH" => "Schweiz");  
foreach($laender as $kuerzel => $name)  
{  
  echo "Das Länderkuerzel von $name lautet $kuerzel<br>\n";  
}

Auch dieses Beispiel liest nacheinander alle Elemente des Arrays $laender aus. Allerdings liest es sowohl den Schlüssel als auch den Wert aus. Der Schlüssel wird in der Variablen $kuerzel und der Wert in der Variablen $name zur Verfügung gestellt. Beide Variablen werden anschließend mit einer echo-Anweisung im Browser ausgegeben.

Bei mehrdimensionalen Arrays müssen Sie ein wenig aufmerksamer vorgehen, da Sie mehrere foreach-Schleifen verschachteln müssen. Nehmen Sie einmal an, Ihr mehrdimensionales Array verfügt über zwei Dimensionen, dann müssten Sie auch entsprechend zwei foreach-Schleifen verschachteln.

$mehrdim[0][0] = 4;  
$mehrdim[0][1] = 5;  
$mehrdim[1][0] = 41;  
$mehrdim[1][1] = 51;  
foreach($mehrdim as $v1)  
{  
  foreach($v1 as $v2)  
  {  
    echo "$v2<br>\n";  
  }  
}

Da die Elemente des Arrays $mehrdim in der ersten Ordnung ebenfalls Arrays sind, wird in der Variablen $v1 immer ein Array gespeichert. Mit einer weiteren foreach-Schleife werden nun alle Elemente dieses Arrays abgearbeitet. Das gerade aktuelle Element steht dann in der Variablen $v2 zur Verfügung. Da es keine weiteren Dimensionen gibt, können Sie $v2 einfach im Browser ausgeben.

# switch-Anweisung

Mit einer switch-Anweisung können Sie das Verketten mehrerer if-Anweisungen umgehen, da eine Variable zur Überprüfung angegeben wird und anschließend mehrere mögliche Fälle notiert werden sowie entsprechende Anweisungen, die in einem solchen Fall ausgeführt werden sollen.

switch(mixed)  
{  
  case value1: [Anweisungsblock];  
  case value2: [Anweisungsblock];  
  case valueN: [Anweisungsblock];  
  default: [Anweisungsblock];  
}

Als mixed können Sie eine beliebige Variable notieren. Die Anweisung case leitet einen neuen Fall ein, und hinter ihr wird der Wert notiert, der diesem Fall entspricht. Nach dem Doppelpunkt folgen dann die Anweisungen. Jetzt ergibt sich eine Besonderheit. Wenn nach dem Anweisungsblock für den einen Fall keine weiteren Anweisungen ausgeführt werden sollen, müssen Sie break notieren, damit der Schleifendurchlauf beendet wird. Andernfalls werden auch die Anweisungsblöcke der nachfolgenden Fälle ausgeführt – und zwar so lange, bis eine break-Anweisung oder das Ende des switch-Anweisungsblocks folgt.

Falls die Variable über einen Wert verfügt, der in keinem Fall bearbeitet wird, wird der Anweisungsblock des Falles default ausgeführt.

Im nachstehenden Beispiel ist $i eine Variable des Typs Integer.

switch($i)  
{  
  case 0:  
    echo "\$i hat den Wert 0<br>\n";  
    break;  
  case 1:  
    echo "\$i hat den Wert 1<br>\n";  
    break;  
  case 2:  
    echo "\$i hat den Wert 2<br>\n";  
    break;  
  default:  
    echo "\$i ist weder 0, 1 oder 2<br>\n";  
    break;  
}

Je nachdem, über welchen Wert $i nun verfügt, wird eine entsprechende Ausgabe im Browser erzeugt. Nach der Ausgabe wird der switch-Anweisungsblock verlassen.

switch($i)  
{  
  case 0: echo "\$i hat den Wert 0<br>\n";  
  case 1: echo "\$i hat den Wert 1<br>\n";  
  case 2: echo "\$i hat den Wert 2<br>\n";  
}

Ohne die break-Anweisungen würden in dem Fall, dass $i den Wert 0 besitzt, alle drei echo-Anweisungen ausgeführt werden, bei dem Wert 1 nur die beiden letzten Anweisungen und bei 2 nur die letzte Anweisung.

switch($str)  
{  
  case "Hallo":  
    echo "\$str hat den Wert Hallo<br>\n";  
    break;  
  case "Welt":  
    echo "\$str hat den Wert Welt<br>\n";  
    break;  
  default:  
    echo "unbekannter Wert<br>\n";  
    break;  
}

Wie Sie in diesem Beispiel sehen können, ist auch die Überprüfung einer Zeichenkette möglich. Denken Sie immer an die Anführungszeichen, und verwenden Sie am besten immer doppelte Anführungszeichen. So können Sie dann auch auf Escape-Sequenzen wie z. B. \n (neue Zeile) überprüfen.

# Einbinden von Dateien

Sehr oft wird in PHP die Möglichkeit verwendet, externe Dateien während der Laufzeit mit in das PHP-Script einzubinden. Solche Dateien sind häufig PHP-Scripts, in denen Konfigurationsvariablen definiert wurden. Der Vorteil liegt auf der Hand: Änderungen müssen nur einmal zentral in einer Datei vorgenommen werden und nicht in mehreren Dateien.

Zum Einbinden von Dateien stehen Ihnen zwei Varianten zur Verfügung:

Mit der Funktion require wird eine eingebundene Datei ausgeführt und eingebunden sowie ein schwerer Fehler ausgelöst, sobald es zu Problemen bei der Ausführung kommt. Das einbindende Script wird in diesem Fall sofort beendet.
Mit der Funktion include wird ebenfalls eine Datei ausgeführt und eingebunden, aber nur ein normaler Fehler ausgegeben, sobald es zu Problemen bei der Ausführung kommt. Das einbindende Script wird in diesem Fall NICHT sofort beendet.

Beide Funktionen arbeiten im Prinzip gleich und unterscheiden sich nur in der Behandlung von Fehlern. Am sichersten ist die Verwendung von require, da mögliche Codefragmente nicht im Browser ausgegeben werden, und es so auch nicht zu möglichen Schäden an Datenbanken kommen kann. Das ist ein Sicherheitsaspekt, den Sie auf jeden Fall beachten sollten.

Die Datei autos.php:

<?php  
  $autos = Array("BWZ Z4","VW Golf","Porsche Boxster");  
?>

Die Datei autos_zeigen.php:

<?php  
  require("autos.php");  
  foreach($autos as $auto)  
  {  
    echo "$auto<br>\n";  
  }  
?>

Dieses Beispiel würde nun die in der Datei autos.php an das Array $autos zugewiesenen Werte ausgeben, wenn während des Einbindens der Datei autos.php kein Fehler auftritt. Ein Fehler wäre z. B., wenn die Datei nicht vorhanden wäre. Dies würde zu einem sofortigen Programmabbruch führen.

Wäre die Datei autos.php mit include eingebunden worden, hätte dies zwar auch einen Fehler erzeugt, es würden anschließend aber noch mehr Fehlermeldungen folgen, da auch das Array $autos nicht definiert wurde, auf das aber explizit zugegriffen werden soll.

Da der PHP-Compiler beim Einbinden von Dateien wieder in den HTML-Modus schaltet, muss PHP-Code in einer einzubindenden Datei innerhalb von gültigen PHP-Tags notiert werden. Wenn das Ende der Datei erreicht ist, schaltet der Compiler wieder zurück in den PHP-Modus.

# Schleifen steuern

Die Anweisung break sollte Ihnen nun bekannt sein. Sie beendet einen aktuellen Schleifendurchlauf. Unabhängig davon, ob die Anweisung in einer for- oder foreach-Schleife oder in einer switch-Anweisung notiert wird, führt die Ausführung der break-Anweisung dazu, dass die Schleife vollständig beendet oder dass der Anweisungsblock verlassen wird.

Zusätzlich gibt es noch die Anweisung continue. In einer Schleife bewirkt ihre Ausführung, dass der gerade aktuelle Schleifendurchlauf übersprungen wird, d. h., er wird beendet und der nächste wird eingeleitet.

$zahlen = Array(1,2,3,4,5,6);  
foreach($zahlen as $zahl)  
{  
  if($zahl == 4) continue;  
  echo "$zahl<br>\n";  
}

Dieses Beispiel würde die Zahlen 1, 2, 3, 5 und 6 im Browser ausgeben, da die Ausgabe der Zahl 4 mit der continue-Anweisung übersprungen wird.

# Alternative Syntax

Anstelle der geschweiften Klammern können Sie auch eine andere Schreibweise für die in diesem Kapitel vorgestellten Kontrollstrukturen if, while, for, foreach und switch verwenden. Die öffnende Klammer wird dabei durch einen Doppelpunkt und die schließende entweder durch endif, endwhile, endfor, endforeach oder endswitch ersetzt.