PHP-Tutorial: Schleifen

Und schon sind wie bei Schleifen. Schleifen (engl. loops) geben uns die Möglichkeit speziellen Code wiederholt auszuführen. Ich werde hier nur auf die wesentlichen Gedanken der Schleifen eingehen.

While


Schauen wir uns zunächst die while-Schleife an. Sie ist die einfachste Schleife in PHP. Syntax:

1
2
3
4
while (BEDINGUNG)
{
ANWEISUNGEN;
}

Wie man sich vielleicht denken kann, werden die ANWEISUNGEN so lange ausgeführt, wie die BEDINGUNG wahr ist, und damit aufgehöhrt, wenn die BEDINGUNG falsch ist. Es sei gleich angemerkt, dass es sich als sinnvoll herausstellen wird, in dem Anweisungsblock etwas der Bedingung zu ändern, denn sonst wird die BEDINGUNG immer wahr oder falsch bleiben, und im Fall dass sie wahr ist, bekommt man eine sogenannte Endlosschleife, die also nie abbricht (beispielsweise: while(true) { ... }). Ich habe natürlich ein kleines Beispiel um die Sache nicht zu theoretisch zu gestalten:

1
2
3
4
5
6
7
8
9
10
11
<?php
$zaehler = 0;
while ($zaehler < 20)
{
if ($zaehler % 5 == 0)
{
echo "<br/>";
}
echo ++$zaehler . ", ";
}
?>

Man beachte das Präinkrement, die Variable $zaehler (oft Laufvariable genannt) wird also mit jedem Schleifendurchlauf um eins erhöht und die Schleife bricht ab, wenn $zaehler einen Wert größer gleich 20 erreicht hat (die Bedingung ist nur wahr für Werte kleiner 20). Des weiteren lernt ihr gleich noch einen neuen operator kennen, den Modulo-Operator (%). Er die erste durch die zweite Zahl und gibt uns den ganzzahligen Rest zurück, zum Beispiel ist 6 % 5 = 1 (denn es bleibt bei der Division der Rest 1) und 10 % 5 = 0 (denn 10 geht ohne Rest durch 5 zu teilen). Das bedeutet im Beispiel also immer wenn die Zahl durch 5 teilbar ist, machen wir einen HTML-Zeilenumbruch. Wir bekommen also folgende ausgabe (probierts einfach aus: schleifen.bsp.tgz (712,00 B) ):
<br/>1, 2, 3, 4, 5, <br/>6, 7, 8, 9, 10, <br/>11, 12, 13, 14, 15, <br/>16, 17, 18, 19, 20,

Do-While


Eine weitere Schleife ist die do-while-Schleife. Sie ist der while-Schleife ziemlich ähnlich, jedoch wird ihre Bedingung am Ende der Schleife geprüft, das bedeutet sie wird immer mindestens einmal durchlaufen, egal ob die Bedingung wahr ist oder nicht! Syntax:

1
2
3
4
do
{
ANWEISUNGEN;
} while (BEDINGUNG);

Beachtet hier das Semikolon (;) am Ende, keine der anderen Kontrollstrukturen benötigt es, aber hier ist es zwingend erforderlich! Noch ein kleines Beispiel (Download: schleifen.bsp.tgz (712,00 B) ):

1
2
3
4
5
6
7
<?php
$i = 10;
do
{
echo $i;
} while ($i < 0);
?>

Die Schleife wird genau einmal durchlaufen, denn die Bedingung ist falsch, aber sie wird durchlaufen!

For


Die for-Schleife ist im Prinzip auch nichts anderes, eine Schleife halt. Hier initialisiert man die Laufvariable direkt in der Schleife, gibt zudem die Abbruchbedingung an und die Zählweise vor:

1
2
3
4
for (STARTWERT; BEDINGUG; ZAEHLWEISE)
{
ANWEISUNGEN;
}

Zur Erklärung macht sich ein kleines Beispiel recht gut (Download: schleifen.bsp.tgz (712,00 B) ):

1
2
3
4
5
6
7
8
9
10
<?php
for ($zaehler = 0; $zaehler < 20; $zaehler++)
{
if ($zaehler % 5 == 0)
{
echo "<br/>";
}
echo ($zaehler + 1) . ", ";
}
?>

Dieses Beispiel ergibt die selbe Ausgabe wie unser while-Beispiel. Wir starten mit dem Wert 0 für unsere Laufvariable $zaehler (STARTWERT: $zaehler = 0) und wollen so lange laufen wie $zahler kleiner als 20 ist (BEDINGUNG: $zaehler < 20). Dabei erhöhen wir unseren $zaehler jeweils um eins (ZAEHLWEISE: $zaehler++) pro Schleifendurchlauf. Also alles ganz simpel ;-)

Foreach


Die foreach-Schleife ist eine sehr nette Schleife, welche uns leicht über ein Array iterieren lässt. Syntax ist denkbar einfach:

1
2
3
4
foreach (ARRAY as VALUE)
{
ANWEISUNGEN;
}

Wir durchlaufen die Schleife also (Anzahl der Elemente im ARRAY)-oft, wobei wir den Wert des Elementes jeweils in die Variable VALUE schreiben (in Wahrheit übernehmen wir die Referenz und können so auch das Element im ARRAY direkt ändern). Ein kleines Beispiel gefällig?:

1
2
3
4
5
6
<?php
$arr = array("eins", "zwei", "drei");
foreach ($arr as $value) {
echo "Value: " . $value . "<br/>";
}
?>

Wir geben hier also einfach alle Werte des Arrays $arr nacheinander aus. Für assoziative Arrays (ihr erinnert euch, hier haben die Elemente einen Namen) gibt es eine spezielle Variante mit der man die Keys (Namen oder auch Schlüssel) der Elemente mit in den Anweisungen verarbeiten kann. Gleich ein Beispiel:

1
2
3
4
5
6
<?php
$arr = array("eins" => 1, "zwei" => 2, "drei" => 3, "fuenf" => 5);
foreach ($arr as $key => $value) {
echo "$arr[" . $key . "] => " . $value . " <br/>";
}
?>

Die Namen werden in jedem Schleifendurchlauf in $key und die Werte in $value geschrieben, wir lassen uns also in einem schönen Format alle Elemente ausgeben (Download: schleifen.bsp.tgz (712,00 B) ).

Break und Continue


Nun lernt ihr noch zwei für Schleifen sehr wichtige Schlüsselworte. Mit break bricht man eine Schleife an der aktuellen Position ab und setzt die Verarbeitung des Codes hinter der aktuellen Schleife fort (den Abbruch mittels break kennt ihr schon von switch). Mit continue bricht man den aktuellen Schleifendurchlauf ab und fängt wieder beim Schleifenstart an, also wird der Rest der Schleife nicht mehr betrachtet und man beginnt sofort mit dem nächsten Durchlauf. Es gibt natürlich ein Beispiel:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
<?php
for ($zaehler = 0; $zaehler < 20; $zaehler++)
{
if ($zaehler % 2 == 0)
{
continue;
}
echo $zaehler . ", ";
if ($zaehler == 15)
{
break;
}
}
?>

Und was wird diese Beispiel wohl ausgeben? Wenn $zaehler durch 2 teilbar ist führen wir ein continue aus, also gehen in den nächsten Schleifendurchgang. Das bedeutet gerade Zahlen werden nie ausgegeben. Wenn $zaehler den Wert 15 hat brechen wir die komplette Schleife ab. Das bedeutet unsere Ausgabe lautet wie folgt: 1, 3, 5, 7, 9, 11, 13, 15, (Download: schleifen.bsp.tgz (712,00 B) ).
Bei den anderen Schleifen funktionieren diese Konstrukte natürlich äquivalent.

© 2009-2017 by Martin Scharm