for Schleife in PHP: Aufbau und Elemente erklärt

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

Die PHP for Schleife ist das Werkzeug für alles, was eine feste Anzahl an Durchläufen hat. Sie vereint Zählvariable, Abbruchbedingung und Schrittweite in einer einzigen Zeile, wodurch auf einen Blick erkennbar ist, wie oft der Block läuft. Dieser Artikel zeigt den Aufbau, verschachtelte Durchläufe, das Rückwärtszählen, mehrere Zähler nebeneinander sowie die Performance-Falle mit count() in der Bedingung.

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 direkt 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 PHP for Schleife: 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 Zählvariablen unterschiedlich heißen, sonst überschreiben Sie den Stand der äußeren 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.

Rückwärts zählen mit der PHP for Schleife

Eine for-Schleife läuft nicht zwingend von klein nach groß. Tauschst Sie Startwert, Bedingung und Schrittweite aus, können Sie genauso gut von oben nach unten zählen. 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 Rückwärtszählen auf die Abbruchbedingung. Schreiben 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 in einer PHP for Schleife führen

Im for-Header dürfen Sie mehrere Ausdrücke per Komma trennen. Damit können Sie zwei Zählvariablen gleichzeitig laufen lassen, eine vorwärts und eine rückwärts. 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 Hälfte der Vergleiche gegenüber einer naiven Lösung mit nur einem Zähler. Mehr zur String-Länge 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 dafür 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 äußeren Schleife heraus, continue 2; überspringt den Rest der inneren Schleife und beginnt die nächste Iteration der äußeren.

<?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 hätten wir nur die Zeile abgebrochen und die Suche danach unnötig fortgesetzen. Setzen Sie die Zahl bewusst ein, sie macht Code klarer als Hilfsvariablen wie $gefunden = true;. Verwechsle die Konstrukte aber nicht mit dem ähnlich klingenden exit(), das das gesamte Skript beendet.

Performance-Falle der PHP for Schleife: count() im Kopf

Eine der häufigsten Schwachstellen in PHP-Code: count() direkt 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 Länge in einer Variable ist ein Klassiker und kostet sich nichts, ausser einer zusätzlichen 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.

PHP for Schleife, foreach oder while: Entscheidungshilfe

PHP bietet sich mehrere Schleifenarten an und Anfänger fragen sich oft, welche sie nehmen sollen. Die Faustregel ist einfach: kennst Sie die Anzahl der Durchläufe vorher und brauchen einen Index, nimm for. Iterierst Sie über ein Array oder einen Iterator, ist foreach meist die sauberste Wahl. Hängt 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 sind, hilft das Diagramm als Startpunkt. Greifen Sie im Schleifenkörper auf den numerischen Index zu, ist for klar im Vorteil.

range() als Alternative zur PHP for Schleife

Manchmal ist die Schreibweise mit for umständlicher, 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 Zählvariable.

<?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 Einträge, 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. Dafür 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.

Häufige Fragen zur for-Schleife

Rund um die PHP for Schleife tauchen vier Fragen immer wieder auf.

Damit deckt die PHP for Schleife alle Fälle ab, in denen die Anzahl der Durchläufe vorher feststeht. Jetzt weiter zur foreach-Schleife oder die Sprachreferenz im PHP-Handbuch nachschlagen.