Verstehe die Grundlagen von while-Schleife und do-while-Schleife in PHP

Sie befinden sich: Home > Php > Verstehe die Grundlagen von while-Schleife und do-while-Schleife in PHP

Sie fragen sich, was die Funktion while() in PHP macht? Nun, while() ist eine iterative Funktion, die es Ihnen ermöglicht, Code-Abschnitte mehrmals auszuführen. Es wird beispielsweise auch verwendet, um den Inhalt einer Datenbank (wie MySQLi) oder einfach den Inhalt einer Datei auszugeben. PHP bietet While-Schleifen, For-Schleifen und Foreach-Schleifen.

Die Syntax der Funktion sieht wie folgt aus:

while (Bedingung) {
    Code-Abschnitt
}

Wenn die Bedingung zutrifft, wird der Code-Abschnitt wiederholt ausgeführt, bis die Bedingung nicht mehr erfüllt ist. Die Bedingung der while-Schleife wird als Boolean ausgewertet: true (Schleife wird ausgeführt) oder false (Schleife endet).

Als Beispiel können Sie eine While-Schleife erstellen, um eine Liste aller Zahlen von 1 bis 10 auszugeben.

Beispiel 1:

<?php
$zahl = 1;
while ($zahl <= 10) {
    echo $zahl;
    $zahl++;
}
?>

Ausgabe:

12345678910

Diese Schleife wird so lange ausgeführt, bis die Bedingung ($zahl ⇐ 10) nicht mehr erfüllt ist. In diesem Fall wird der Wert der Variablen $zahl nach jedem Durchlauf um 1 erhöht.

Ablaufdiagramm vom Beispiel 1:

Das Diagramm beschreibt den Ablauf des gegebenen PHP-Codes. Zunächst wird die Variable $zahl mit dem Wert 1 initialisiert. Dann wird in jeder Schleifendurchlauf geprüft, ob der Wert von $zahl kleiner oder gleich 10 ist. Wenn dies der Fall ist, wird der aktuelle Wert von $zahl ausgegeben und der Wert von $zahl um 1 erhöht. Anschließend wird die Schleife wiederholt, um den nächsten Wert zu überprüfen. Sobald der Wert von $zahl 11 erreicht hat, wird die Schleife beendet und das Programm endet.

Als zweites Beispiel können Sie eine While-Schleife erstellen, um die Summe aller Elemente in einem Array auszugeben.

Beispiel 2:

<?php
$summe = 0;
$array = array(1, 2, 3, 4, 5);
$laenge = count($array);
$i = 0;
while ($i < $laenge) {
    $summe = $summe + $array[$i];
    $i++;
}
echo "Die Summe ist $summe.";
?>

Ausgabe:

Die Summe ist 15.

In diesem Beispiel wird die While-Schleife so lange ausgeführt, bis der Wert der Variablen $i der Länge des Arrays entspricht. In jedem Durchlauf wird der Wert der Variablen $summe um den Wert des aktuellen Elements im Array erhöht.

Ablaufdiagramm vom Beispiel 2:

Das Diagramm zeigt den Ablauf des gegebenen PHP-Codes. Der Startpunkt ist der Anfang des Codes.

Das Programm verwendet eine while-Schleife, die so lange ausgeführt wird, wie die Bedingung ($i < $laenge) erfüllt ist. Innerhalb der Schleife wird die Summe erhöht, indem der Wert des aktuellen Elements des Arrays zu der Summe hinzugefügt wird.

Danach wird der Index um 1 erhöht, um das nächste Element des Arrays zu verwenden. Dieser Schleifenvorgang wird so oft wiederholt, bis alle Elemente des Arrays durchlaufen wurden.

Das Diagramm zeigt auch, wie der Array-Index auf das Array-Element zugreift, um es zur Summe hinzuzufügen. Das Diagramm endet mit dem Output der Summe.

Als weiteres Beispiel können Sie eine While-Schleife verwenden, um alle Buchstaben des Alphabets auszugeben.

Beispiel 3:

<?php
$buchstabe = 'a';
while ($buchstabe <= 'z') {
    echo $buchstabe."; ";
    if($buchstabe=='z'){
    	break;
    }
    $buchstabe++;
}
?>

Ausgabe:

a; b; c; d; e; f; g; h; i; j; k; l; m; n; o; p; q; r; s; t; u; v; w; x; y; z;

Erklärung des Beispiel 3:

Der obige PHP-Code erstellt eine Schleife, die dazu dient, alle Buchstaben des Alphabets aufzulisten. Hierzu wird der Variable $buchstabe der Wert „a“ zugewiesen. Anschließend wird eine while-Schleife erstellt, die so lange ausgeführt wird, bis die Variable $buchstabe einen Wert von „z“ erreicht. In jeder Iteration der Schleife wird der Wert der Variable $buchstabe ausgegeben und anschließend um eins erhöht. Falls die Variable $buchstabe den Wert „z“ erreicht, wird die Schleife mittels eines break-Befehls beendet, um ein unendliches Iterieren zu verhindern.

Ablaufdiagramm vom Beispiel 3:

Das Diagramm zeigt den Ablauf des Codes, der einen Buchstaben von a bis z ausgibt, indem eine While-Schleife verwendet wird. Der Code beginnt mit der Initialisierung der Variablen ($buchstabe = 'a') und geht dann in die While-Schleife. In der Schleife wird die Bedingung ($buchstabe ⇐ „z“) geprüft und wenn sie wahr ist, wird der Code innerhalb der Schleife ausgeführt. Innerhalb der Schleife wird der Wert von $buchstabe ausgegeben, und dann wird überprüft, ob $buchstabe den Wert „z“ hat. Wenn dies der Fall ist, wird die Schleife mit dem break-Statement abgebrochen. Wenn der Wert von $buchstabe nicht „z“ ist, wird die Schleife fortgesetzen. Das Diagramm zeigt auch, dass der Code bei Abschluss der Schleife endet.

Beispiel 4:

<?php
$i = 0;

while ($i < 10) {
    $i++;
    if($i % 2 == 1) {
        continue;
    }
    echo $i . "; ";
}
?>

Ausgabe:

2; 4; 6; 8; 10;

Erläuterung:

Dieser PHP-Code erstellt eine while Schleife, die 10 mal ausgeführt wird. In jeder Iteration wird die Variable $i hochgezählt. Mit dem if-Statement wird überprüft, ob die Variable $i ungerade ist (nicht durch 2 teilbar). Ist dies der Fall, wird der continue Befehl ausgeführt und der Rest des Codes in der Schleife übersprungen. Dadurch werden nur die geraden Zahlen ausgegeben.

Ablaufdiagramm vom Beispiel 4:

Das Diagramm erklärt den gegebenen Code, indem es die Schritte visualisiert, die von der Start- bis zur Endanweisung des Codes ausgeführt werden. Der Code initialisiert eine Variable $i mit dem Wert 0 und führt dann eine While-Schleife aus, die so lange weiterläuft, wie $i kleiner als 10 ist. Innerhalb der Schleife erhöht der Code $i um 1 und überprüft dann, ob $i eine ungerade Zahl ist. Wenn ja, springt der Code zum nächsten Durchlauf, ohne $i auszugeben. Wenn $i gerade ist, gibt der Code $i gefolgt von einem Semikolon aus und setzen dann die Schleife fort. Falls $i den Wert 10 erreicht, wird die While-Schleife beendet.

do-While-Schleife

Eine Do-While-Schleife ist einer While-Schleife sehr ähnlich, außer dass der boolesche Ausdruck nur am Ende jeder Iteration getestet wird, nicht am Anfang. Der Hauptunterschied zu einer normalen While-Schleife besteht darin, dass eine Do-While-Schleife garantiert mindestens einmal durchlaufen wird.

Beispiel 5:

<?php
$i = 0;
do {
    if ($i == 3) {
        $i++;
        continue;
    }
    echo $i;
    $i++;
} while($i <= 10);
?>

Ausgabe:

01245678910

Erklärung:

Der oben gezeigte PHP-Code verwendet eine do-while Schleife, um eine Reihe von Zahlen von 0 bis 10 auszugeben. Als Erstes initialisiert der Code eine Variable $i mit dem Wert 0. Danach wird eine do-while Schleife gestartet, die so lange ausgeführt wird, bis $i größer als 10 ist. In der Schleife wird eine if-Anweisung verwendet, um zu überprüfen, ob $i den Wert 3 hat.

Wenn das der Fall ist, wird $i um eins erhöht und die nächste Anweisung wird mit dem Befehl continue übersprungen. Andernfalls wird der Wert von $i ausgegeben und anschließend um eins erhöht. Am Ende der Schleife wird der neue Wert von $i überprüft, um zu sehen, ob die Schleife weiter ausgeführt werden muss. Wenn ja, wird der Block erneut ausgeführt, andernfalls wird die Schleife beendet.

Ablaufdiagramm vom Beispiel 5:

Das Diagramm visualisiert den Ablauf des gegebenen PHP-Codes. Der Startknoten „Start“ führt zum Knoten „Setzen Sie i auf 0“, der den Wert von i auf 0 setzen. Der Knoten „Setzen Sie i auf 0“ führt zum Knoten „Beginne Schleife“, der die do-while-Schleife darstellt.

Innerhalb der Schleife wird zuerst geprüft, ob i kleiner oder gleich 10 ist. Wenn ja, wird geprüft, ob i gleich 3 ist. Wenn i gleich 3 ist, wird i um 1 erhöht und der Rest des Schleifenblocks wird übersprungen. Andernfalls wird der Wert von i ausgegeben und i um 1 erhöht, bevor die Schleife fortgesetzen wird.

Wenn i nicht kleiner oder gleich 10 ist, endet die Schleife und das Diagramm endet mit dem Knoten „Ende“.

do-while: pruefe später, laufe mindestens einmal

Die klassische while-Schleife prüft ihre Bedingung am Anfang. Manchmal wollen Sie aber, dass der Schleifenkörper auf jeden Fall einmal ausgeführt wird, bevor überhaupt über einen Abbruch entschieden wird. Genau dafür gibt es do-while. Typische Fälle sind interaktive Eingaben, einmalige Abfragen mit anschließender Wiederholung oder API-Aufrufe, bei denen Sie erst nach der ersten Antwort weißt, ob noch eine weitere Runde nötig ist.

<?php
declare(strict_types=1);

$eingabe = '';
do {
    /* Sobald wir hier landen, fragen wir den Benutzer mindestens einmal */
    $eingabe = strtolower(trim((string)readline('Weiter? (j/n): ')));
} while ($eingabe !== 'j' && $eingabe !== 'n');

echo "Antwort erfasst: {$eingabe}
";
?>

Der Kopf wird erst nach dem ersten Durchlauf ausgewertet. Achten Sie auf das abschließende Semikolon hinter while(...), das vergisst man leicht. Wenn Sie die Bedingung gleich am Anfang prüfen wollen, ist eine normale while-Schleife oder eine for-Schleife meistens die bessere Wahl. In der Praxis sehen Sie do-while oft beim Validieren von Formulareingaben, beim erneuten Anfragen einer API nach einem Fehler oder beim Lesen aus einer Quelle, die mindestens einen Datensatz liefert.

Endlosschleife mit break: ein einfacher Event-Loop

Ein bewusst geschriebenes while (true) ist kein Bug, sondern ein Pattern. Sie bauen einen Loop, der so lange läuft, bis er von innen heraus über break beendet wird. Das ist die Grundform vieler kleiner Worker-Skripte, Polling-Schleifen und CLI-Tools.

<?php
declare(strict_types=1);

$tick = 0;
while (true) {
    $tick++;

    /* Hole das naechste Event aus der Queue, hier nur simuliert */
    $event = $tick === 5 ? 'shutdown' : 'heartbeat';

    if ($event === 'shutdown') {
        echo "Beende Loop nach {$tick} Ticks.
";
        break;
    }

    echo "Tick {$tick}: {$event}
";
    usleep(200000); /* 200 ms Pause */
}
?>

Wichtig ist, dass es immer mindestens einen klar definierten Ausstieg gibt. Bei langlebigen Workern bietet sich zusätzlich eine Signal-Behandlung an, damit Sie den Loop sauber beenden können, etwa über pcntl_signal(). Für weniger kritische Skripte reicht ein einfacher Zähler oder ein Zeit-Limit.

Dateien zeilenweise lesen mit fgets()

Eines der häufigsten Praxisbeispiele für while ist das zeilenweise Einlesen einer Datei. Sie öffnest die Datei mit fopen(), lesen mit fgets() Zeile für Zeile und brichst ab, sobald der Rückgabewert false wird. Der Vorteil gegenüber file_get_contents() liegt darin, dass selbst riesige Logfiles speicherschonend verarbeitet werden.

<?php
declare(strict_types=1);

$pfad = __DIR__ . '/access.log';
$handle = fopen($pfad, 'rb');

if ($handle === false) {
    throw new RuntimeException("Konnte {$pfad} nicht oeffnen.");
}

$zeile = 0;
while (($puffer = fgets($handle)) !== false) {
    $zeile++;
    if (str_contains($puffer, ' 500 ')) {
        echo "Fehler in Zeile {$zeile}: " . trim($puffer) . "
";
    }
}

fclose($handle);
?>

Beachten Sie den strikten Vergleich mit !== false. Eine leere Zeile würde sonst fälschlicherweise als Schleifenende interpretiert, weil PHP einen leeren String in Booleschen Kontext als false wertet. Wer komplette CSV-Dateien einlesen, kann auf gleiche Weise mit fgetcsv() arbeiten.

Datenbank-Iteration: PDOStatement::fetch in while

Beim Auslesen von Datenbank-Ergebnissen mit PDO haben Sie zwei Wege: fetchAll() lädt alles in den Speicher oder Sie nutzen fetch() in einer Schleife. Für große Resultsets ist die Schleife klar im Vorteil, weil PHP nur die aktuelle Zeile im RAM hält.

<?php
declare(strict_types=1);

$pdo = new PDO('mysql:host=localhost;dbname=shop;charset=utf8mb4', 'user', 'pass', [
    PDO::ATTR_ERRMODE            => PDO::ERRMODE_EXCEPTION,
    PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
]);

$stmt = $pdo->prepare('SELECT id, email FROM kunden WHERE newsletter = 1');
$stmt->execute();

while ($zeile = $stmt->fetch()) {
    /* Pro Iteration genau ein Datensatz, sehr speicherschonend */
    echo "#{$zeile['id']}: {$zeile['email']}
";
}
?>

Die Bedingung $zeile = $stmt->fetch() kombiniert Zuweisung und Prüfung. Sobald keine Zeile mehr kommt, liefert fetch() ein false zurück und die Schleife endet. Das Muster ist ein PHP-Klassiker und kommt sich in fast jedem Projekt unter, das Datenbanken lesen. Praktischer Nebeneffekt: Sie können das Statement sichekt im laufenden Loop weiterverarbeiten, etwa Zeilen filtern, in eine andere Tabelle schreiben oder ein Streaming-CSV erzeugen, ohne den kompletten Resultset jemals als Array zu materialisieren.

Generatoren mit while und current/next konsumieren

Generatoren produzieren Werte erst, wenn sie gebraucht werden. Meistens iterieren Sie sie mit foreach, manchmal brauchen Sie aber feinere Kontrolle und greifst sichekt auf current(), next() und valid() zu. Genau dann passt eine while-Schleife perfekt.

<?php
declare(strict_types=1);

function fibonacci(int $max): Generator
{
    $a = 0;
    $b = 1;
    while ($a <= $max) {
        yield $a;
        [$a, $b] = [$b, $a + $b];
    }
}

$gen = fibonacci(50);

while ($gen->valid()) {
    echo $gen->current() . ' ';
    $gen->next();
}
echo "
";
?>

Sie behandeln den Generator dabei wie einen Iterator. valid() ist die Schleifenbedingung, current() liefert den aktuellen Wert und next() rückt vor. Vorteil: Sie können mittendrin reagieren, etwa abbrechen, sobald ein bestimmter Wert kommt, oder Werte in mehreren Schritten konsumieren.

Abbruch über eine Bedingung statt über einen Zaehler

Eine while-Schleife wird besonders lesbar, wenn Sie nicht hochzählst, sondern fachlich abbrichst. Das ist der größte Unterschied zu einer typischen for-Schleife. Sie sagst dem Code: laufe so lange, bis Bedingung X erfüllt ist. Wann das passiert, hängt von den Daten ab.

<?php
declare(strict_types=1);

$preis  = 100.0;
$rabatt = 0.92; /* 8 Prozent pro Schritt */

$schritte = 0;
while ($preis > 50.0) {
    $preis *= $rabatt;
    $schritte++;
}

echo "Nach {$schritte} Schritten liegt der Preis bei " . number_format($preis, 2) . " Euro.
";
?>

Solche Schleifen tauchen in Simulationen, bei Bisektionsverfahren, beim Abbau einer Warteschlange oder beim Zählen von Versuchen bis zu einem Erfolg auf. Der Code ist deutlich näher an der Aufgabenbeschreibung, weil die Bedingung das fachliche Ziel widerspiegelt. Wer einen klassischen Zähler braucht, ist mit for besser bedient. Bei datenabhängigen Abbruchkriterien spielt while dagegen seine Stärke aus, weil Sie die Logik nicht in einen festen Indexbereich pressen müssen.

Pitfall: vergessener Zaehler und der GAU der Endlosschleife

Die häufigste Falle bei while ist trivial und peinlich zugleich: Sie vergisst, den Wert zu ändern, der die Bedingung kippen sollte. Ergebnis ist eine echte Endlosschleife, die das Skript blockiert, im schlimmsten Fall den FPM-Worker oder den CLI-Prozess abstürzen lässt.

<?php
declare(strict_types=1);

/* FALSCH: $i wird nie veraendert */
$i = 0;
while ($i < 10) {
    echo "Hallo {$i}
";
    /* hier fehlt $i++; */
}

/* RICHTIG */
$i = 0;
while ($i < 10) {
    echo "Hallo {$i}
";
    $i++;
}
?>

Drei Gewohnheiten helfen, das zu vermeiden. Erstens: Wenn Sie weißt, wie oft die Schleife laufen soll, nimm sichekt eine for-Schleife, dort sehen Sie den Zähler im Kopf. Zweitens: Setzen Sie in CLI-Skripten ein hartes Sicherheits-Limit, etwa if ($iter++ > 10000) break;. Drittens: Lesen Sie die Schleife laut vor und frage sich, welche Zeile die Bedingung ändern soll. Findest Sie sie nicht, ist es ein Bug.

Lebenszyklus einer while-Schleife im Diagramm

Damit der Ablauf in Erinnerung bleibt, hilft eine kleine Skizze. Sie zeigt, wie PHP zwischen Bedingungsprüfung, Körper und Abbruch wechselt. Genau diese Reihenfolge entscheidet, warum ein do-while mindestens einmal läuft und ein while auch null Mal laufen kann.

flowchart TD
    A[Start] --> B{Bedingung wahr?}
    B -- ja --> C[Schleifenkoerper]
    C --> B
    B -- nein --> D[Ende]

Wenn Sie das Diagramm im Kopf hast, fallen sich auch die typischen Bugs schneller auf. Eine fehlende Variablen-Änderung im Körper bedeutet, dass der Pfeil von C zurück nach B nichts ändert. Genau das ist der klassische GAU. Mit dieser Sicht und den Beispielen oben haben Sie das Werkzeug while in voller Bandbreite einsatzbereit, von der einmaligen Eingabe bis zum kleinen Event-Loop.