Schleifen in PHP verstehen und anwenden

for-Schleife

Starten wir unsere Erlebnistour durch die Welt der Schleifen mit der klassischen for-Schleife.

Eine for-Schleife besteht immer aus folgenden Teilen:

• Startwert der Schleifenvariablen: Wir bestimmen einen Startwert in einer sog. Schleifenvariablen.
• Schleifenbedingung : Die Schleife wird wiederholt, solange die Prüfung eines booleschen Ausdrucks true ergibt und die Schleifenbedingung damit erfüllt ist. Sobald sie nicht (mehr) erfüllt ist, wird die Schleife beendet.
• Veränderung der Schleifenvariablen: Nach jedem Schleifendurchlauf wird die Schleifenvariable verändert (zum Beispiel durch Hoch- oder Runterzählen um 1).
• Körper der Schleife: Beinhaltet die Anweisung bzw. den Anweisungs-Block, der zu jedem Durchlauf der Schleife ausgeführt wird.

Die Syntax einer for-Schleife sieht in PHP beispielhaft dann so aus:

Wie wir sehen, wird die gesamte Schleifenkonstruktion im Schleifenkopf gesteuert. Der Startwert der Schleifenvariablen $i ist 0. Sie wird nach jedem Schleifendurchlauf um +1 erhöht. Die Schleife wird solange wiederholt, bis die Prüfung $i <= 5 false wird - und das ist dann der Fall, sobald $i den Wert 6 hat. Die Schleife wird dann beendet.

Das Ergebnis der Schleife ist, dass die echo-Anweisung im Schleifenkörper insgesamt fünfmal ausgeführt wird und folgenden Output erzeugt:

0
1
2
3
4

In einem Aktivitätsdiagramm lässt sich die Logik dahinter so darstellen:

Dadurch, dass wir die gesamte Steuerung der Schleife in einer Zeile, dem Schleifenkopf, vornehmen können, ist die for-Schleife besonders übersichtlich. Sie eignet sich außerdem bestens, wenn wir wissen, wie oft ein Programmvorgang wiederholt werden soll.

Vorsicht: Endlosschleifen

Hüten Sie sich vor Schleifen, die Ihren Code ins Verderben führen, da sie niemals enden! Was glauben Sie, ist das Resultat des folgenden Codes?

for($i = 0; $i <= 5; $i--){
    echo $i ."";
}

Richtig: Da die Bedingung $i <= 5 nie false wird, wird die Schleife eine sehr lange Zeit laufen! Wir sitzen in einer Endlosschleife fest. Häufige Folge: Programmabsturz.

Passen sie also immer gut auf Ihre Schleifenvariable auf, dass sie die Schleifenbedingung irgendwann auch erfüllen kann.

while-Schleife

Standard-Schleife Nummer 2: Die berühmte while-Schleife. Sie bietet sich idealerweise an, wenn wir zu Beginn noch nicht wissen, wieviele Schleifendurchläufe wir brauchen.

Hier ein Beispiel: Wir wollen, dass die Schleife solange wiederholt wird, bis ein Würfel (Zufallsgenerator) die Zahl 6 geworfen hat. Das kann nach einem Versuch bereits der Fall sein, dann gäbe es nur einen Schleifendurchlauf. Es kann aber auch nach 2,3,4,5,... Versuchen die Zahl 6 gewürfelt werden (dann wird die Schleife 2,3,4,5,... Mal durchlaufen). Der Code dazu lautet:

$zahl = 0;
while($zahl != 6){
    $zahl = rand(1,6);
    echo $zahl . "<br>";
}

Die Schleifenbedingung in runden Klammern lautet $zahl != 6. Das bedeutet, dass die Schleife solange wiederholt wird, wie die Variable $zahl nicht den Wert 6 hat.

Konkret: Wir erhalten mit echo solange die Zahlen 1 bis 5 angezeigt, bis der Zufallsgenerator der PHP-Funktion rand() die Zahl 6 liefert. Diese wird dann noch mit echo angezeigt, die Schleife aber daraufhin beendet, da die Schleifenbedingung ja false ist, d.h. nicht mehr erfüllt ist.

Der Unterschied zur for-Schleife ist, dass bei der while-Schleife nur die Schleifenbedingung im Schleifenkopf (in den runden Klammern) steht.

Die Schleifenvariable wird außerhalb der Schleifenkonstruktion definiert. Streng genommen handelt es sich bei $zahl zunächst um eine x-beliebige Variable, die wir zur Steuerung der Schleife einsetzen können und die erst dadurch zu einer wirklichen Schleifenvariablen wird.

Auch die Veränderung der Schleifenvariable ist im Schleifenkopf nicht zu finden, sondern muss in geeigneter Weise vom Programmierer irgendwo innerhalb der Schleife selbst geschrieben werden (in unserem Beispiel änderte rand(1,6) die Schleifenvariable bei jedem Durchlauf).

Der Schleifenkopf der while-Schleife ist somit erheblich kürzer als bei einer for-Schleife. Allerdings ist die Schleifenkonstruktion insgesamt komplizierter.

Unterschied zur for-Schleife

Stellen wir doch einmal die Syntax einer while-Schleife einer for-Schleife gegenüber. Wir wollen hierzu die Zahlen 0 bis 9 folgendermaßen am Bildschirm sehen:

0, 1, 2, 3, 4, 5, 6, 7, 8, 9,

Um das mit einer while-Schleife hinzukriegen, sieht der Code so aus:

$i = 0;
while($i < 10){
    echo $i . ', ';
    $i++;
}

Und nun das Gleiche alternativ mit einer for-Schleife:

for($i = 0; $i < 10; $i++){
    echo $i . ', ';
}

Wie wir sehen, müssen wir bei der while-Schleife im oberen Bereich außerhalb der Schleife eine Variable definieren, die wir dann als Schleifenvariable einsetzen. Außerdem müssen wir mit i++ eine Veränderung der Schleifenvariable innerhalb des Schleifenkörpers einbauen. Tun wir das nicht, bleiben wir in der Endlosschleife gefangen, da die Schleifenbedingung $i < 10 niemals erfüllt werden kann.

Klare Sache: Die for-Schleife ist einfacher und übersichtlicher. Dennoch ist die kompliziertere while-Schleife die flexibelste Schleife überhaupt, mit der wir "wirklich jedes Problem lösen können" (Jan Teriete).

do-while Schleife

Die do-while-Schleife ist der while-Schleife recht ähnlich. Der Unterschied ist aber, dass die Prüfung zur Wiederholung erst am Ende nach einem Schleifendurchlauf erfolgt. Das hat zur Konsequenz, dass die Schleife in jedem Fall mindestens einmal durchlaufen wird:

Im Gegensatz zu anderen Schleifentypen gibt es bei der do-while-Schleife also auf jeden Fall eine Code-Runde gratis 😉

Das Würfelprogramm sieht mit einer do-while-Schleife so aus:

$zahl = 6;

do{
    $zahl = rand(1,6);
    echo $zahl . "";
}
while($zahl != 6);

Syntaktisch hat sich einiges getan: Der auszuführende Code-Block wird nun vom Schlüsselwort do eröffnet, während am Ende while mit der Prüfung zur Wiederholung in runden Klammern steht.

Es spielt nun keine Rolle, ob die Schleifenbedingung zu Beginn erfüllt ist oder nicht, wenn es darum geht, dass der Code-Block mindestens einmal ausgeführt werden soll. Genau das ist in unserem Beispiel auch der Fall: Denn obwohl die Schleifenbedingung nicht erfüllt ist ($zahl = 6), wird die Schleife trotzdem ausgeführt. Mit einer for- oder while-Schleife hätten wir keinen einzigen Schleifendurchlauf bekommen, da dort die Prüfung ja am Anfang steht.

foreach-Schleife

Dieser Schleifentyp ist etwas ganz Besonderes.

Die foreach-Schleife ist nämlich speziell dafür da, die einzelnen Elemente eines Arrays zu durchlaufen (Fachbegriff: Iteration) und für jedes dieser Elemente die immer gleichen Anweisungen auszuführen. Die allgemeine Syntax sieht so aus:

Nach dem Schlüsselwort foreach schreiben wir in die runden Klammern zunächst die Variable, die das Array hält, gefolgt vom Schlüsselwort as. Der letzte Teil des Schleifenkopfs ist die Schleifenvariable $sV.

Es gibt soviele Schleifendurchläufe wie es Elemente im Array gibt. Bei jedem Durchlauf wird die Schleifenvariable $sV mit dem Wert desjenigen Array-Elements belegt, das gerade an der Reihe ist. Beim ersten Durchlauf wird der Wert des ersten Array-Elements in die Variable $sV kopiert. Beim zweiten Durchlauf wird der Wert des zweiten Array-Elements in $sV kopiert und so weiter. Auf diese Weise können wir auf allen Elementen eines Arrays dieselbe Anweisung durchführen.

Sehen wir uns das in einem Beispiel an:

$falken = array(
        "Turmfalke",
        "Buntfalke",
        "Steppenfalke",
        "Silberfalke",
        "Sakerfalke");

foreach($falken as $sV){
   echo $sV . "
";
}

Wir erstellen zunächst ein Array von Strings und speichern es in der Variablen $falken. In Zeile 8-10 befindet sich unsere foreach-Schleife. Mit dieser können wir alle Elemente des Arrays durchlaufen und für jedes dieser Element diesselbe Anweisung ausführen (jedes Element wird mit echo nacheinander am Bildschirm ausgeben).

foreach arbeitet mit Kopien

Aber Achtung 🧐: Bei jedem Schleifendurchlauf wird jeweils nur der Wert des jeweiligen Array-Elements in die Variable $sV kopiert. Da wir innerhalb der foreach-Schleife somit nur mit Kopien der einzelnen Elemente arbeiten, haben Veränderungen keine Auswirklungen auf den "Originalzustand" des Arrays.

Was das konkret bedeutet, können wir hier sehen:

$falken = array(
        "Turmfalke",
        "Buntfalke",
        "Steppenfalke",
        "Silberfalke",
        "Sakerfalke");

// 1. foreach-Schleife
foreach($falken as $sV){
     $sV = "Adler";
}

// 2. foreach-Schleife
foreach ($falken as $sV){
     echo $sV . "
";
}

Wir weisen in der ersten foreach-Schleife der Schleifenvariablen $sV den Wert "Adler" zu. Man könnte jetzt ja auf die Idee kommen, dass alle Array-Elemente den Wert "Adler" zugewiesen bekommen.

Das ist aber gerade nicht der Fall! Denn die String-Zuweisung betrifft ausschließlich die Schleifenvariable, die mit Kopien der Array-Elemente arbeitet. Die Inhalte des Arrays, die "Originale", bleiben deshalb von der Zuweisung völlig unberührt.

Das können wir mit der zweiten foreach-Schleife beweisen. Diese gibt nämlich mittels echo die Werte des Arrays wider und diese lauten:

Turmfalke
Buntfalke
Steppenfalke
Silberfalke
Sakerfalke

Falken bleiben Falken.

Verschachtelte Schleifen

Innerhalb einer Schleife können beliebige Anweisungen stehen. Damit ist es auch möglich, dass Schleifen andere Schleifen enthalten. Wir sprechen dann von inneinander verschachtelten Schleifen. Theoretisch können wir beliebig oft verschachteln. Der Einfachheit halber beschränken wir uns hier aber auf eine einfache Verschachtelung mit zwei Schleifen.

Bei einer einfachen Verschachtelung haben wir immer eine äußere und eine innere Schleife. Das sieht dann so aus:

for($i = 1; $i < 3; $i++){ //äußere Schleife
    echo "<strong> $i. Durchlauf äußere Schleife </strong> <br>";
    for($y = 1; $y < 4; $y++){ //innere Schleife
        echo " $y. Durchlauf innere Schleife<br>";
    }
}                

Dieser Code produziert folgende Ausgabe im Browser:

1. Durchlauf äußere Schleife
1. Durchlauf innere Schleife
2. Durchlauf innere Schleife
3. Durchlauf innere Schleife
2. Durchlauf äußere Schleife
1. Durchlauf innere Schleife
2. Durchlauf innere Schleife
3. Durchlauf innere Schleife

Was passiert hier genau?

Es wird beim ersten Durchlauf der äußeren Schleife die innere Schleife zum ersten Mal komplett durchlaufen. Danach kommt es zum zweiten Durchlauf der äußeren Schleife. Die innere Schleife wird nochmals komplett durchlaufen.

Man kann das Prinzip der einfachen Verschachteltung mit einer Uhr vergleichen. Die äußere Schleife entspricht dabei der Stundenanzeige und die innere Schleife der Minutenanzeige. Erst, wenn die Minuten einen kompletten Umlauf (60) hinter sich haben, erhöht sich die Stundenanzeige um 1. Nun kommt es zu einem neuen Durchlauf der Minuten und wenn dieser vollendet ist, erhöht sich die Stundenanzeige wieder um 1 und so weiter.

Mehrdimensionale Arrays und verschachtelte Schleifen

Der volle Nutzen von verschachtelten Schleifen zeigt sich in der Arbeit mit mehrdimensionalen Arrays. Sehen wir uns ein kleines 2D-Array an:

// 2D-Array für Buchstabenpaare:
$buchstabenpaare = array( array("a", "A"),
                          array("b", "B"),
                          array("c", "C"),
                          array("d", "D"),
                          array("e", "E"));

Das übergeordnete Array $buchstabenpaare hält als einzelne Elemente selbst weitere (anonyme) Arrays mit jeweils zwei String-Elementen (die Buchstabenpaare).

Wir setzen nun eine verschachtelte Schleife ein und nutzen die Schleifenvariablen als jeweilige index-Werte. Der erste Index-Wert steht für eines der fünf untergeordneten Subarrays. Mit dem zweiten Index-Wert steuern wir dann ein bestimmtes Element des jeweiligen Subarraysarrays an:

for($i = 0 ; $i < count($buchstabenpaare); $i++){ //äußere Schleife
    for($j = 0 ; $j < count($buchstabenpaare[$i]); $j++){ //innere Schleife
        echo $buchstabenpaare[$i][$j]." ";
    }
}

Die äußere Schleife wird so oft wiederholt, wie das übergeordnete Array $buchstabenpaare untergeordnete Array-Elemente hat, also fünf Mal. Wir können die Anzahl der Elemente übrigens mit der PHP-Funktion count() erhalten.

Die innere Schleife kümmert sich dann der Reihe nach um jedes dieser fünf Arrays, durchläuft deren Elemente (das sind immer zwei Strings) und gibt sie mit echo am Bildschirm aus.

continue und break

Die beiden Anweisungen continue und break können zur Steuerung von Schleifenkonstruktionen verwendet werden, um diese vorzeitig zu beenden.

continue

Wenn wir die Anweisung continue innerhalb einer Schleife einsetzen, sorgt dies für den Abbruch des aktuellen Schleifendurchlaufs.

Sehen wir uns ein Beispielprogramm an:

for($i = 1; $i < 11; $i++){
    if($i % 2 != 0){
        continue;
    }
    echo "Zeile  $i<br>";
}

Innerhalb der for-Schleife befindet sich in den Zeilen 2-4 eine if-Kontrollstruktur, die mittels einer Modulo-Operation prüft, ob die aktuelle Schleifenvariable $i keine gerade Zahl ist.

Ist $i keine gerade Zahl, wird der aktuelle Schleifendurchlauf beendet und es kommt nicht zur echo-Anweisung. Stattdessen beginnt der nächste Schleifendurchlauf.

Auf diese Art werden nur gerade Zahlen ausgegeben. Der Code erzeugt somit folgende Ausgabe:

Zeile 2
Zeile 4
Zeile 6
Zeile 8
Zeile 10

break

Im Gegensatz zu continue beendet die Anweisung break nicht nur den aktuellen Schleifendurchlauf, sondern bricht die gesamte Schleife ab:

for($i = 1; $i < 11; $i++){
    if($i == 6){
        break;
    }
    echo "Zeile  $i<br>";
}

Sobald die Schleifenvariable den Wert 6 annimmt, sorgt das break dafür, dass die Schleife sofort beendet wird:

Zeile 1
Zeile 2
Zeile 3
Zeile 4
Zeile 5

Übungen

for($i = 0; $i < 5; $i++) {
    if ($i > 2) {
        echo $i;
    }
}

$i = 0;
$y = 10;

while($i <= $y){
    $i++;
    $y--;
  }
  echo $i . " " . $y;

$img ="mario"; //oder "megaman"
$anzahl = 6;
        
    if($figur == "mario"){
        $img = "<img src='mario.png'>";
    }
    else if($figur == "megaman"){
        $img = "<img src='megaman.png'>";
    }
     else{
        echo "Diese Figur gibt es nicht.";
    }

    for($i = 0; $i < $anzahl; $i++){
        echo $img;
    }
}