Bedingungen

Bedingungen und Verzweigungen werden für Fallunterscheidungen verwendet und dienen zur Steuerung des Programmablaufs. Mit Hilfe der Fallunterscheidung ist es z. B. möglich, eine andere Aktion auszuführen, wenn Variable a größer als Variable b ist, wie wenn Variable b größer oder gleich Variable a ist. Einen Programmcode für eine solche Fallunterscheidung mittels einer einfachen Verzweigung sehen Sie weiter unten.

Bedingungen benötigen immer einen Wert vom Typ boolean. Um einen solchen Wert zu erzeugen, stehen uns verschiedene sogenannte Vergleichsoperatoren zur Verfügung. Eine Liste von Vergleichsoperatoren und deren Bedeutung sehen Sie in der untenstehenden Tabelle:

a == b	Wert a ist gleich b
a === b	Wert und Typ a ist gleich b
a != b	Wert a ist ungleich b
a !== b	Wert und Typ a ist ungleich b
a > b	Wert a ist größer als b
a >= b	Wert a ist größer als oder gleich b
a < b	Wert a ist kleiner als b
a <= b	Wert a ist kleiner als oder gleich b

Natürlich können Sie Vergleichsoperatoren nicht nur bei Verzweigungen nutzen, sondern auch bei einer Schleifen-Bedingung (dazu später mehr). Das Zuweisen einer Bedingung zu einer Variablen speichert den Wert vom Typ boolean in der Variable ab. Als Bedingung kann neben einem mit den Vergleichsoperatoren erzeugten Wert auch einfach eine Variable vom Typ boolean abgefragt werden. Auch das Abfragen eines Rückgabewerts einer Funktion in Bedingungen ist möglich.

Bei der Verwendung der Operatoren >== und === sowie != und !== ist Vorsicht geboten. Wie bereits in der Tabelle erwähnt, vergleicht == und != lediglich den Wert und === und !== hingegen den Wert und den Datentyp. So ergibt z. B. '12' == 12 den Wert true. Die Bedingung '12' === 12 ergibt hingegen false. Besondere Vorsicht ist z. B. hier bei der Funktion strpos() geboten. Stellen Sie sich vor, Sie suchen nach einem Zeichen. Dieses befindet sich nun am Anfang der Zeichenkette (Index 0). Eine Bedingung zur Prüfung, ob die Suche erfolglos geblieben ist, würde wie folgt aussehen: strpos('abc', 'a') === false. Würden Sie hier statt dem ===-Operator den ==-Operator verwenden, so würde Ihre Bedingung nicht nur zutreffen, wenn die Suche erfolglos bleibt (und der Wert false ist), sondern auch, wenn sich der gesuchte Wert am Anfang der Zeichenkette befindet (Rückgabewert 0).

Um komplexere Bedingungen zu erstellen, ist es notwendig mehrere Bedingungen zu verknüpfen. Hierfür dient das logische Und && und das logische Oder ||. Bei der Kombination von Und und Oder müssen (runde) Klammern zur Gruppierung genutzt werden. Alternativ zu den Zeichen && und || können auch die Schlüsselwörter and und or verwendet werden. Für eine Bedingung mit dem logischen Operator Exklusiv-Oder gibt es das Schlüsselwort xor. Jeder Wert vom Typ boolean kann mit Hilfe eines Ausrufezeichens ! (Nicht-Operator) „negiert“ (umgekehrt) werden. Dabei entspricht dann !true dem Wert false.

Einfache Verzweigung

Verzweigungen dienen zur Steuerung des Programmablaufs. So ist es Ihnen möglich, in einem bestimmten Fall eine oder mehrere Aktion(en) auszuführen. Bei einer einfachen Verzweigung wird die Fallunterscheidung mit Hilfe des Schlüsselworts if durchgeführt. Wir notieren bei einer einfachen Verzweigung also das Schlüsselwort if gefolgt von einem runden Klammernpaar, in welchem wir die Bedingung angeben. Das Ganze wird nun von einem Block mit geschweiften Klammern gefolgt. Alle Anweisungen, die sich innerhalb des Blocks befinden, werden nur dann ausgeführt, wenn die angegebene Bedingung zutrifft.

<?php
if ($a == $b)
{
    // Anweisungen wenn Bedingung zutrifft
}
?>

Möchten wir zusätzlich zu dem Fall, dass die Bedingung zutrifft auch den Fall, dass die Bedingung nicht zutrifft behandeln, so notieren wir nach dem if-Block das Schlüsselwort else gefolgt von einem weiteren Block. Alle Anweisungen des else-Blocks werden dann nur ausgeführt, wenn die Bedingung nicht zutrifft.

<?php
if ($a == $b)
{
    // Anweisungen wenn Bedingung zutrifft
}
else
{
    // Anweisungen wenn Bedingung nicht zutrifft
}
?>

Innerhalb des if- und else-Blocks können weitere Verzweigungen folgen. Eine solche Verschachtelung könnte z. B. so aussehen:

<?php
if ($a == $b)
{
    // Anweisungen wenn a gleich b ist
}
else
{
    if ($a > $b)
    {
        // Anweisungen wenn a größer als b ist
    }
    else
    {
        // Anweisungen wenn a kleiner als b ist
    }
}
?>

Eine Verschachtelung im else-Block (so wie oben) lässt sich mit Hilfe des Schlüsselworts elseif eleganter lösen. Der obige Code könnte somit auch wie folgt dargestellt werden:

<?php
if ($a == $b)
{
    // Anweisungen wenn a gleich b ist
}
elseif ($a > $b)
{
    // Anweisungen wenn a größer als b ist
}
else
{
    // Anweisungen wenn a kleiner als b ist
}
?>

Befindet sich innerhalb einer der Blöcke nur eine Anweisung, so können die geschweiften Klammern einfach weggelassen werden. Dies zeigt das folgende Beispiel:

<?php
$a = 43;
$b = 29;

if ($a == $b)
	echo '$a ist gleich $b!';
elseif ($a > $b)
	echo '$a ist größer als $b!';
else
	echo '$a ist kleiner als $b!';
?>

Befindet sich sowohl im if- als auch im else-Block eine Anweisung, um einer Variablen einen Wert zuzuweisen, so erhalten Sie mit Hilfe des ternären Operators ?: eine verkürzte Schreibweise. Schauen wir uns zunächst einen Konstrukt aus if- und else-Block an:

<?php
if ($a == $b)
{
    $c = 'gleich';
}
else
{
    $c = 'ungleich'
}
?>

Die verkürzte Schreibweise mit dem ternären Operator sieht wie folgt aus:

<?php
$c = ($a == $b) ? 'gleich' : 'ungleich';
?>

Der Syntax ist also wie folgt: Bedingung ? WertWennWahr : WertWennUnwahr. Bezeichnet wird ein solches Konstrukt auch als In-Line-Abfrage.

Mehrfache Verzweigung

Möchten Sie einen Wert auf viele verschiedene Werte abprüfen, so wirken viele if-, elseif- und else-Blöcke schnell unübersichtlich. Oft kann hier eine mehrfache Verzweigung mittels switch-case Abhilfe schaffen.

Bei einer solchen mehrfachen Verzweigung notieren wir das Schlüsselwort switch gefolgt von einem runden Klammernpaar, in welchem der zu überprüfende Wert (z. B. eine Variable) angegeben wird. Das Ganze wird nun von einem Block aus geschweiften Klammern gefolgt:

<?php
switch ($a)
{
    // case-Blöcke
}
?>

Innerhalb des Blocks werden nun die einzelnen Fälle mit Hilfe von case-Blöcken geprüft. Hierfür notieren wir das Schlüsselwort case gefolgt von einem Wert, der mit dem oben angegebenen Wert verglichen werden soll. Zum Schluss notieren wir einen Doppelpunkt :. Alle nun gefolgten Anweisungen werden nur ausgeführt, wenn die Bedingung zutrifft. Um einen case-Block zu „beenden“, notieren wir das Schlüsselwort break gefolgt von einem Semikolon (es handelt sich hierbei um eine Anweisung).

<?php
case 1:
    // Anweisungen wenn Wert 1 entspricht
    break;
?>

Ein switch-Block enthält für gewöhnlich mehrere case-Blöcke. Optional kann ein switch-Block noch einen default-Block enthalten. Der default-Block ist vom Aufbau mit dem case-Block fast identisch. Der Unterschied liegt darin, dass beim default-Block kein Wert angegeben wird. Die Anweisungen des default-Blocks werden nur ausgeführt, wenn keine der anderen Bedingungen zutrifft.

Möchten Sie z. B., wenn die zu überprüfende Variable den Wert 1 oder den Wert 2 hat, die gleichen Anweisungen ausführen, so ist es möglich, case-Blöcke zu stapeln. Dies sieht dann z. B. so aus:

<?php
case 1:
case 2:
    // Anweisungen wenn Wert 1 oder 2 entspricht
    break;
?>

Hier nun ein vollständiges Beispiel zur Verwendung von mehrfachen Verzweigungen:

<?php
$monat = 7;

switch ($monat)
{
	case 1:
		echo 'Januar';
		break;
	case 2:
		echo 'Februar';
		break;
	case 3:
		echo 'März';
		break;
	case 4:
		echo 'April';
		break;
	case 5:
		echo 'Mai';
		break;
	case 6:
		echo 'Juni';
		break;
	case 7:
		echo 'Juli';
		break;
	case 8:
		echo 'August';
		break;
	case 9:
		echo 'September';
		break;
	case 10:
		echo 'Oktober';
		break;
	case 11:
		echo 'November';
		break;
	case 12:
		echo 'Dezember';
		break;
}
?>

Wichtig: Mit Hilfe von switch-case können keine Wertebereiche, sondern lediglich Einzelwerte überprüft werden. Für die Überprüfung von Wertebereichen müssen Sie if-else verwenden.

Übrigens: Auch wenn eine switch-case-Verzweigung mehr Programmzeilen als eine if-else-Verzweigung erzeugt, gilt die switch-case-Verzweigung in solchen Situationen wie das Beispiel oben als übersichtlicher.

Übrigens: Die in unseren Code-Ausschnitten enthaltene(n) Zeilenumbrüche, Leerzeichen und Einrückungen sind oft nicht zwingend notwendig. Wir empfehlen Ihnen jedoch, diese ebenfalls zu verwenden, da dadurch Ihr Programmcode für Sie selbst und für Andere viel leichter zu lesen ist. Als Einrückung wird zumeist 1 Tab bzw. 4 Leerzeichen verwendet. Die meisten Quellcode-Editoren führen die Einrückungen automatisch hinzu.