Die while-Schleife: Einführung und Tipps für den Umgang

1. Einführung

In der Programmierung muss man oft die gleichen Aktionen immer wieder hintereinander ausführen. Zum Beispiel:

• Alle Elemente einer Liste durchgehen.
• Werte von der Tastatur einlesen, bis der User das richtige eingibt.
• Die Summe aller Zahlen von 1 bis 100 berechnen.
• Den User nach dem Passwort fragen, bis es korrekt ist.

Wenn du das alles ohne Schleifen umsetzen willst, wird der Code lang, langweilig und überhaupt nicht skalierbar. Stell dir vor, du schreibst einen Taschenrechner und willst die Zahlen von 1 bis 10 per Hand addieren:

int sum = 0;
sum += 1;
sum += 2;
sum += 3;
// ... und so weiter, 10 Mal. Uff.

Du bist gelangweilt, bevor du fertig bist! Die Lösung – Schleifen. Damit kannst du Wiederholungen kurz und verständlich beschreiben. Heute schauen wir uns die einfachste, aber verdammt nützliche Schleife an – while.

2. Einführung in die while-Schleife

Syntax und Grundschema

Die while-Schleife ist der "Papagei" in der Programmierwelt: Sie wiederholt denselben Code-Block, solange eine Bedingung erfüllt ist. Sobald die Bedingung nicht mehr wahr ist, verstummt der Papagei (die Schleife endet).

while (bedingung)
{
    // Schleifenrumpf
}

Diagramm

Hier ist ein einfaches Flussdiagramm, um die Funktionsweise der while-Schleife zu verstehen:

3. Beispiele: while-Schleife in Aktion

Klassischer Zähler

Wir machen ein einfaches Programm, das von 1 bis 5 zählt und die Zahlen ausgibt:

int i = 1;
while (i <= 5)
{
    Console.WriteLine($"Schritt Nr. {i}");
    i++; // Nicht vergessen, den Zähler zu erhöhen!
}
// Gibt aus:
// Schritt Nr. 1
// Schritt Nr. 2
// Schritt Nr. 3
// Schritt Nr. 4
// Schritt Nr. 5

Achte darauf: Wenn du vergisst, die Variable i zu erhöhen, endet die Schleife nie (unser Papagei wird unsterblich und wiederholt sich ewig). Das nennt man eine Endlosschleife – ganz schön gruselig.

Eingabe von der Tastatur bis zum richtigen Wert

Oft wird eine Schleife genutzt, um den User so lange zu "nerven", bis er die richtige Antwort gibt:

string password = "";
while (password != "qwerty")
{
    Console.Write("Gib das Passwort ein: ");
    password = Console.ReadLine();
}
Console.WriteLine("Willkommen!");

Hier fragt das Programm nach dem Passwort, bis du das magische "qwerty" eintippst. Nicht vergessen: Wenn du die Zeile password = Console.ReadLine(); entfernst, wird die Schleife wieder endlos (fragt nach dem Passwort, liest aber nie die Eingabe – hängt für immer wie ein kaputter Roboter).

4. Arten und Einsatzszenarien der while-Schleife

Normale while-Schleife

Diese Schleife prüft – wie oben gezeigt – die Bedingung vor der ersten Iteration. Ist die Bedingung sofort falsch, wird der Schleifenrumpf kein einziges Mal ausgeführt.

Beispiel: Bedingung ist sofort falsch

int i = 10;
while (i < 5)
{
    Console.WriteLine(i); // Wird nie ausgeführt!
}

Das ist eigentlich logisch. Genau so, wie es hier steht.

Verschachtelte while-Schleifen

Manchmal braucht man eine Schleife in der Schleife. Zum Beispiel alle Zeilen durchgehen und in jeder Zeile alle Zeichen prüfen. An dieser Stelle ist das noch ein Abenteuer, aber hier ein einfaches Beispiel:

int i = 1;
while (i <= 3)
{
    int j = 1;
    while (j <= 2)
    {
        Console.WriteLine($"i = {i}, j = {j}");
        j++;
    }
    i++;
}

// i = 1, j = 1
// i = 1, j = 2
// i = 2, j = 1
// i = 2, j = 2
// i = 3, j = 1
// i = 3, j = 2

Verschachtelte Schleifen schauen wir uns in ein paar Vorlesungen genauer an, wollte dich nur schon mal erschrecken :)

Endlosschleife

Manchmal enden Schleifen, manchmal leben sie ewig.

while (true)
{
    Console.WriteLine("Ich bin ewig!");
}

Wird selten benutzt, meistens für irgendwelche Hintergrundprozesse (z.B. Serverbetrieb), aber kommt auch in der Praxis vor.

5. Wie du keine Dummheiten machst: Häufige Fehler mit while

In der Programmierung ist eine Schleife wie Strom: cool, aber du solltest die Sicherheitsregeln kennen.

Problem 1: Endlosschleife aus Versehen

Sehr oft vergessen Anfänger, die Variable zu aktualisieren, von der die Bedingung abhängt. Die Schleife läuft dann "endlos" und du musst das Programm zwangsweise stoppen (zum Beispiel mit Ctrl + C).

int i = 1;
while (i <= 5)
{
    Console.WriteLine(i);
    // i++;  // UPS! i erhöhen vergessen
}

Problem 2: Falsch gesetzte Bedingung

Manchmal gräbt sich der Entwickler selbst ein Loch: Die Bedingung ist nie wahr. Die Schleife wird dann gar nicht ausgeführt.

int i = 10;
while (i < 5)
{
    Console.WriteLine(i); // Dieser Code wird nie ausgeführt.
    i++;
}

Problem 3: Fehler beim Datentyp

In der Schleifenbedingung muss immer ein boolescher Ausdruck stehen – das Ergebnis muss also true oder false sein.

int number = 5;
while (number) // Fehler! Erwartet wird bool, nicht int.
{
    number--;
}