for Schleife in PHP: Aufbau und Elemente erklärt

Sie befinden sich: Home > Php > for Schleife in PHP: Aufbau und Elemente erklärt

Die for Schleife in PHP ist ein mächtiges Werkzeug, um Codeabläufe mehrfach auszuführen. Sie arbeitet mit einer Zählvariablen, einer Bedingung und einer Veränderung, wodurch sich Wiederholungen präzise steuern lassen. Dieser Artikel erklärt, wie die for-Schleife funktioniert, wann sie eingesetzen wird und wie sie sich von anderen Schleifen unterscheidet. Praxisnahe Beispiele zeigen ihre Vorteile, etwa bei der effizienten Ausgabe von Listen.

Dies wird besonders deutlich, wenn man beispielsweise eine Topliste mit 100 Bannern und Links ausgeben möchte. Stellen Sie man sich vor, dass man 100-mal dasselbe mit kleinen Abweichungen programmieren müsste, ist man sehr dankbar, dass es Schleifen gibt. Man umschließt den Code, der sich wiederholen soll, mit der Schleife und hat sich in diesem Beispiel das Hundertfache an Arbeit gespart, Schleifen sei Dank!

For-Schleifen werden in der Regel durch drei Konfigurationen definiert, nämlich durch die Schleifenvariable, die Bedingung und die Veränderung. Der Aufbau der Schleife sieht wie folgt aus:

<?php
/**
* Beispiel für den Aufbau, einer for(){} Schleife
*/
for(/* SCHLEIFENVARIABLE */; /* BEDINGUNG */; /* VERÄNDERUNG */){
    /* PHP-CODE INNERHALB DER SCHLEIFE */
}
?>

Nehmen wir uns ein Beispiel zur Hand. Wir möchten eine Mitgliederliste erstellen, bei der jedes Mitglied eine eigene neue Zeile bekommen soll. Natürlich kann man die Mitglieder mit jeder gewünschten Größe ersetzen. Wir konfigurieren die Schleife folgendermaßen:

• Die Schleifenvariable – Diese Variable ist im Prinzip die Variable, nach der sich die ganze Schleife richtet und die sozusagen festlegt, wie oft die Schleife sich wiederholt. In unserem Beispiel enthält sie die Anzahl der Mitglieder. Dies muss vorher natürlich durch PHP-Code bestimmt werden. Die Beispielvariable heißt $anzahlmitglieder und enthält die Zahl 5.
  
  
• Die Bedingung – Solange die angegebene Bedingung erfüllt wird, solange wird auch die Schleife ausgeführt. Diese könnte beispielsweise so aussehen, dass sie so lange erfüllt wird, solange noch mehr als 0 Mitglieder vorhanden sind: $anzahlmitglieder > 0;
  
  
• Die Veränderung – Nach jedem Mal, wenn die Schleife ausgeführt wurde, muss man, um keine Endlosschleife zu erzeugen, eine Veränderung auf die Schleifenvariable ausführen. In unserem Beispiel wird in jedem Schleifendurchlauf ein Mitglied ausgegeben, kann also danach von der Variable abgezogen werden. Unsere Veränderung sieht also wie folgt aus: $anzahlmitglieder--

Fassen wir zusammen

Wir möchten unserer Schleife mitteilen, dass wir fünf Mitglieder haben (Schleifenvariable) und diese ausgeben wollen (Code innerhalb der Schleife). Jedes Mal, wenn ein Mitglied ausgegeben wurde, soll eins abgezogen werden (Veränderung) und der Vorgang soll so lange durchgeführt werden, solange mehr als 0 Mitglieder übrig bleiben (Bedingung). Die Ausgabe unserer Mitgliederliste sieht also folgendermaßen aus:

<?php
/**
* Wir Speichern als erstes in $array_daten['mitglied_name']
* die alle Namen Unser Mitglieder die wir weiter unten
* ausgeben möchten.
*/
$array_daten = array();
$array_daten['mitglied_name'][] = 'Nico';
$array_daten['mitglied_name'][] = 'Frank';
$array_daten['mitglied_name'][] = 'Karl';
$array_daten['mitglied_name'][] = 'Lars';
$array_daten['mitglied_name'][] = 'Isa';
/**
* Nun ermitteln wir mit count() wieviel Array-
* Elemente enthalten sind und Speichern die Anzahl
* in $anzahlmitglieder.
*/
$anzahlmitglieder = count($array_daten['mitglied_name']);
/**
* Nun kommen wir zu unser for Schleife
* um eine Mitgliederlist auszugeben.
*
* In der for Schleife zählen wir von 5 zurück
* bis 1, da bei 0 die Bedingung > 0 nicht mehr
* erfüllt ist und die Schleife endet.
*/
for($anzahlmitglieder; $anzahlmitglieder > 0; $anzahlmitglieder--) {
   /**
   * In $array_key speichern wir die Key Nummer
   * in welchen Step die Schleife ist. Da ein Array
   * bis 0 geht, müssen wir minus eins bei der
   * Key Nummer rechnen.
   */
   $array_key = ($anzahlmitglieder-1);
   /**
   * Mit array_key_exists() prüfen wir, ob es den
   * Key in $array_daten['mitglied_name'] gibt.
   *
   * Wenn der Key gefunden wurde, geben wir
   * diesen aus.
   */
   if (array_key_exists($array_key, $array_daten[ 'mitglied_name']) == true) {
      echo $array_key.'->'. $array_daten['mitglied_name'][$array_key].'<br>';
   }
}
?>

Wenn im Programmcode keine Fehler entstanden sind, dann sollte der Browser, beim Abrufen des Skripts fünf Zeilen ausgeben, für jedes Mitglied eine. Die Ausgabe würde dann, so aussehen:

Erklärung: Dieser PHP-Code dient dazu, eine Liste mit Mitgliedern auszugeben. Zuerst werden die Mitglieder in ein Array gespeichert. Dazu wird ein neues Array namens $array_daten angelegt und in diesem die Namen der Mitglieder als Elemente gespeichert. Dies geschieht mit der Funktion array_daten['mitglied_name'][].

Nachdem alle Namen in das Array gespeichert wurden, wird mit der Funktion count() die Anzahl der Elemente bestimmt und in $anzahlmitglieder gespeichert. Als Nächstes wird eine for Schleife gestartet, die von der Anzahl der Mitglieder $anzahlmitglieder zählt und dann die Schleife beendet.

Innerhalb der Schleife wird die Key Nummer ermittelt und in $array_key gespeichert. Hierbei muss die Nummer minus eins gerechnet werden, da die Key Nummer bei 0 beginnt. Anschließend wird mit der Funktion array_key_exists() geprüft, ob der Key in $array_daten['mitglied_name'] existiert. Wenn ja, wird er ausgegeben.

Schleifenabläufe in der for Schleife mit continue und break steuern

Der Unterschied zwischen „continue“ und „break“ bei einer for-Schleife in PHP besteht darin, wie das Programm auf die aktuelle Iteration der Schleife reagiert. Wenn eine for-Schleife an einer Stellen Sie auf „continue“ stößt, bedeutet dies, dass die aktuelle Iteration übersprungen und die nächste Iteration ausgeführt wird. Wenn die Schleife hingegen auf „break“ stößt, wird die Schleife sichekt beendet und das Programm setzen seine Ausführung außerhalb der Schleife fort.

Mit anderen Worten überspringt „continue“ die aktuelle Iteration der Schleife, während „break“ die Schleife komplett beendet.

Beispiel:

<?php

for ($i = 0; $i < 10; $i++) {
    if ($i % 2 === 0) {
        continue;
    }
    echo "Der Wert von i ist $i <br />";
}

?>

Erklärung:

In diesem PHP-Code wird eine for-Schleife verwendet, um die Schleifenabläufe zu beeinflussen. Die Schleife beginnt mit der Initialisierung von „$i“ auf 0 und endet, wenn „$i“ 10 erreicht. In jeder Iteration der Schleife wird überprüft, ob der Wert von „$i“ durch 2 ohne Rest teilbar ist. Wenn ja, wird die continue Anweisung verwendet, um die aktuelle Iteration der Schleife abzubrechen und mit der nächsten Iteration fortzufahren. Wenn „$i“ nicht durch 2 teilbar ist, wird der Wert von „$i“ ausgegeben. Am Ende der Schleife wird der Wert von „$i“ auf den nächsten Wert erhöht. Dieser Vorgang wird 10 Mal wiederholt, bis „$i“ 10 erreicht.

Beispiel:

<?php
for ($i = 0; $i < 10; $i++) {
    if ($i === 5) {
        break;
    }
    echo "Der Wert von i ist $i <br>";
}
?>

Erklärung:

In diesem PHP-Code wird eine for-Schleife verwendet, um den Wert von „$i“ zu erhöhen und zu verfolgen, wie viele Schleifenabläufe es gibt. Wenn „$i“ den Wert 5 erreicht, wird die Schleife durch das break-Statement beendet. Der Code wird dann alle Werte von i ausgeben, bis „$i“ 5 erreicht. Danach wird die Schleife beendet und der Code wird aufhören auszuführen.

Unterschied zur foreach Schleife

Die for-Schleife und die foreach-Schleife sind beide Programmierkonstrukte in PHP, die verwendet werden, um einen Codeblock wiederholt auszuführen. Der Unterschied zwischen beiden liegt in der Art und Weise, in der sie ausgeführt werden.

Die for-Schleife verwendet eine Zählvariable, um zu bestimmen, wie oft der Codeblock ausgeführt wird. Die Iterationen werden basierend auf dem Anfangswert, dem Endwert und dem Inkrementwert der Zählvariable durchlaufen. Der Codeblock wird so lange ausgeführt, bis die Zählvariable den Endwert erreicht hat. Die foreach-Schleife dagegen wird verwendet, um ein Array Element für Element durchzulaufen. Es verwendet keine Zählvariable, sondern ein Array, um die Iterationen durchzuführen. Der Codeblock wird für jedes Element des Arrays ausgeführt, bis alle Elemente durchlaufen sind.

Alles in allem ist der Unterschied zwischen der for-Schleife und der foreach-Schleife im Wesentlichen die Art und Weise, wie sie ausgeführt werden. Während die for-Schleife basierend auf einer Zählvariable ausgeführt wird, verwendet die foreach-Schleife ein Array, um durchzulaufen.

Mit richtig angewendeten Schleifen kann man viele Problemstellungen lösen und sich vorwiegend viel Arbeit sparen. Natürlich kann man auch das Array sortieren oder die for-Schleife mit ++ in der Veränderung hochzählen lassen. Eine Ausgabe, eines Array kann auch mit einer While -, oder foreach Schleife gemacht werden. Der Vorteil an der for-Schleife ist, dass man ein Stopp -, und Ablauf Bedingung festlegen kann.

Verschachtelte for-Schleifen: Multiplikationstabelle und Grids

Sobald Sie zweidimensionale Strukturen erzeugen wollen, kommen Sie an verschachtelten Schleifen kaum vorbei. Die äußere Schleife steuert die Zeilen, die innere die Spalten. Genau so bauen Sie eine Multiplikationstabelle, ein Schachbrett oder eine HTML-Tabelle aus Daten. Wichtig ist nur, dass die Zaehlvariablen unterschiedlich heißen, sonst überschreiben Sie den Stand der aeusseren Schleife.

Eine kleine Multiplikationstabelle von 1 bis 5 sieht zum Beispiel so aus:

<?php
declare(strict_types=1);

for ($zeile = 1; $zeile <= 5; $zeile++) {
    for ($spalte = 1; $spalte <= 5; $spalte++) {
        printf('%4d', $zeile * $spalte);
    }
    echo PHP_EOL;
}

Die Funktion printf() sorgt mit dem Format %4d für eine saubere Spaltenausrichtung. Nach jeder inneren Schleife setzen echo PHP_EOL; einen Zeilenumbruch, damit die nächste Zeile darunter beginnt.

Rueckwaerts zaehlen mit der for-Schleife

Eine for-Schleife laeuft nicht zwingend von klein nach groß. Tauschst Sie Startwert, Bedingung und Schrittweite aus, können Sie genauso gut von oben nach unten zaehlen. Das ist immer dann praktisch, wenn Sie einen Countdown brauchen oder Elemente in einem Array vom Ende her löscht. Löschen vom Anfang her würde die Indizes verschieben, das endet schnell in unsauberen Ergebnissen.

<?php
declare(strict_types=1);

/* Klassischer Countdown von 10 bis 0 */
for ($i = 10; $i >= 0; $i--) {
    echo $i . ' ';
}
echo PHP_EOL;

/* Sicheres Loeschen ungerader Indizes von hinten */
$werte = [10, 20, 30, 40, 50, 60];
for ($i = count($werte) - 1; $i >= 0; $i--) {
    if ($i % 2 !== 0) {
        unset($werte[$i]);
    }
}
print_r(array_values($werte));

Achten Sie beim Rueckwaertszaehlen auf die Abbruchbedingung. Schreibst Sie versehentlich $i > 0 statt >=, fehlt sich die Null in der Ausgabe. Solche kleinen Off-by-one-Fehler fallen erst später auf und sind dann nervig zu finden.

Mehrere Counter parallel führen

Im for-Header dürfen Sie mehrere Ausdruecke per Komma trennen. Damit können Sie zwei Zaehlvariablen gleichzeitig laufen lassen, eine vorwaerts und eine rueckwaerts. Das ist nützlich, wenn Sie etwa prüfen wollen, ob ein String ein Palindrom ist, oder zwei Arrays parallel von beiden Seiten verarbeiten.

<?php
declare(strict_types=1);

$wort = 'lagerregal';
$laenge = strlen($wort);
$istPalindrom = true;

for ($i = 0, $j = $laenge - 1; $i < $j; $i++, $j--) {
    if ($wort[$i] !== $wort[$j]) {
        $istPalindrom = false;
        break;
    }
}

echo $istPalindrom ? 'Palindrom' : 'kein Palindrom';

Im Beispiel wandern $i und $j in jeder Iteration einen Schritt aufeinander zu. Sobald sie sich treffen, ist der String komplett geprüft. So sparen Sie sich die Haelfte der Vergleiche gegenueber einer naiven Loesung mit nur einem Zaehler. Mehr zur String-Laenge finden Sie im Tutorial zu strlen().

break und continue mit numerischem Argument

In verschachtelten Schleifen reicht ein normales break oft nicht. Es bricht nämlich nur die innerste Schleife ab. Genau dafuer können Sie beiden Anweisungen eine Zahl mitgeben, die angibt, wie viele Schleifen-Ebenen verlassen werden sollen. break 2; springt aus der inneren und der aeusseren Schleife heraus, continue 2; ueberspringt den Rest der inneren Schleife und beginnt die nächste Iteration der aeusseren.

<?php
declare(strict_types=1);

$matrix = [
    [1, 2, 3],
    [4, 99, 6],
    [7, 8, 9],
];

for ($zeile = 0; $zeile < count($matrix); $zeile++) {
    for ($spalte = 0; $spalte < count($matrix[$zeile]); $spalte++) {
        if ($matrix[$zeile][$spalte] === 99) {
            echo "Treffer bei {$zeile}/{$spalte}" . PHP_EOL;
            break 2;
        }
    }
}

Ohne die 2 haetten wir nur die Zeile abgebrochen und die Suche danach unnoetig fortgesetzen. Setzen Sie die Zahl bewusst ein, sie macht Code klarer als Hilfsvariablen wie $gefunden = true;. Verwechsle die Konstrukte aber nicht mit dem aehnlich klingenden exit(), das das gesamte Skript beendet.

Performance-Falle: count() im Schleifenkopf

Eine der häufigsten Schwachstellen in PHP-Code: count() sichekt in der Bedingung der for-Schleife. Sie schreiben es einmal hin und PHP ruft die Funktion in jeder Iteration neu auf. Bei kleinen Arrays merken Sie das nie, bei großen Datenmengen oder verschachtelten Schleifen wird es aber sichtbar.

<?php
declare(strict_types=1);

$daten = range(1, 100000);

/* Schlecht: count() laeuft 100.000 mal */
for ($i = 0; $i < count($daten); $i++) {
    /* ... */
}

/* Besser: einmal zaehlen, dann den Wert wiederverwenden */
$anzahl = count($daten);
for ($i = 0; $i < $anzahl; $i++) {
    /* ... */
}

Das Caching der Laenge in einer Variable ist ein Klassiker und kostet sich nichts, ausser einer zusaetzlichen Zeile. Wenn Sie noch tiefer in die Materie wollen, hilft sich das Tutorial zu microtime(), um den Effekt selbst zu messen. Mehr zu count() finden Sie im passenden Tutorial.

for, foreach oder while: Entscheidungshilfe

PHP bietet sich mehrere Schleifenarten an und Anfaenger fragen sich oft, welche sie nehmen sollen. Die Faustregel ist einfach: kennst Sie die Anzahl der Durchlaeufe vorher und brauchen einen Index, nimm for. Iterierst Sie über ein Array oder einen Iterator, ist foreach meist die sauberste Wahl. Haengt das Ende von einer Bedingung ab, die Sie erst zur Laufzeit kennst, ist while richtig.

flowchart TD
    A[Schleife noetig] --> B{Anzahl bekannt?}
    B -->|Ja, mit Index| C[for]
    B -->|Array iterieren| D[foreach]
    B -->|Bedingung pruefen| E[while]

Die Grafik zeigt den Entscheidungspfad in unter zehn Sekunden. In der Praxis verschwimmen die Grenzen zwar, doch wenn Sie sich unsicher bist, hilft das Diagramm als Startpunkt. Greifst Sie im Schleifenkoerper auf den numerischen Index zu, ist for klar im Vorteil.

range() als Alternative zur for-Schleife

Manchmal ist die Schreibweise mit for umstaendlicher, als es sein müsste. Wenn Sie einfach einen Wertebereich durchgehen wollen, erzeugt sich die Funktion range() ein Array und Sie kombinierst es mit foreach. Das lesen sich kompakter und Sie sparen sich die Zaehlvariable.

<?php
declare(strict_types=1);

/* Klassisch mit for */
for ($i = 1; $i <= 10; $i++) {
    echo $i . ' ';
}
echo PHP_EOL;

/* Kompakt mit range und foreach */
foreach (range(1, 10) as $i) {
    echo $i . ' ';
}
echo PHP_EOL;

/* Mit Schrittweite, hier 2er-Schritte */
foreach (range(0, 20, 2) as $zahl) {
    echo $zahl . ' ';
}

Bei kleinen Bereichen ist range() sehr lesbar. Bei sehr großen Mengen, etwa eine Million Eintraege, frisst das Array allerdings echten Speicher. Dann ist die klassische for-Schleife oder ein Generator mit yield die bessere Wahl, weil sie keinen Zwischenspeicher anlegt.

Praxisbeispiel: ASCII-Pyramide ausgeben

Zum Abschluss ein kleines Beispiel, das alles bisher Gelernte verbindet. Wir geben eine Pyramide aus Sternchen aus, die zentriert wirkt. Dafuer brauchen Sie zwei verschachtelte Schleifen, eine für die Leerzeichen am Anfang der Zeile und eine für die Sternchen.

<?php
declare(strict_types=1);

function pyramide(int $hoehe): void
{
    for ($zeile = 1; $zeile <= $hoehe; $zeile++) {
        /* Leerzeichen vor den Sternen */
        for ($l = 0; $l < $hoehe - $zeile; $l++) {
            echo ' ';
        }
        /* Sternchen, immer eine ungerade Anzahl */
        for ($s = 0; $s < (2 * $zeile) - 1; $s++) {
            echo '*';
        }
        echo PHP_EOL;
    }
}

pyramide(6);

Das Beispiel zeigt schön, dass for-Schleifen nicht nur Daten verarbeiten, sondern auch zur Ausgabe von Mustern taugen. Mit der gleichen Technik bauen Sie Schachbrett-Muster, ein Sieb des Eratosthenes oder Bingo-Karten. Wenn Sie Funktionen wie pyramide() sauber typisiert haben möchten, hilft sich das Tutorial zu Type Hints weiter.