Schleifen

Die while-Schleife: Solange die Bedingung wahr ist

Die while-Schleife (kopfgesteuerte Schleife) nutzt du, wenn die Anzahl der Wiederholungen vorher unbekannt ist. Sie wiederholt den Codeblock, solange eine bestimmte Bedingung true ergibt.

Wichtig: Die Bedingung wird vor dem ersten Durchlauf geprüft. Ist sie von Beginn an false, wird der Codeblock im Inneren niemals ausgeführt. Das ist ideal, wenn du auf ein bestimmtes Ereignis wartest, zum Beispiel auf eine gültige Sensormessung:

let temperatur = 0;
let messungen = 0;

// Läuft nur, solange die Temperatur unter 80 Grad liegt
while (temperatur < 80) {
    // Simuliert einen Temperaturanstieg
    temperatur += Math.floor(Math.random() * 30); 
    messungen++;
    console.log(`Messung ${messungen}: ${temperatur} Grad`);
}
console.log("Warnung: Kritische Temperatur erreicht!");

Die do-while-Schleife: Mindestens eine Ausführung garantiert

Die do-while-Schleife (fußgesteuerte Schleife) ist eng mit der while-Schleife verwandt, hat aber einen entscheidenden Unterschied: Die Bedingung wird erst nach dem Schleifendurchlauf geprüft.

Das bedeutet, der Codeblock wird garantiert mindestens einmal ausgeführt, selbst wenn die Bedingung von Anfang an false ist. Dies ist der perfekte Ansatz für Eingaben von Nutzenden oder Menüs, die zunächst angezeigt werden müssen, bevor eine Eingabe validiert werden kann:

let passwort;

do {
    // Dieser Block läuft garantiert mindestens einmal
    passwort = prompt("Bitte gib das Admin-Passwort ein:");
} while (passwort !== "geheim123"); // Prüfung erfolgt erst am Ende

console.log("Zugriff gewährt.");

Typische Logikfehler: Endlosschleifen und Off-by-One

Da Schleifen den Programmfluss massiv steuern, führen kleine Fehler in der Bedingung schnell zu großen Problemen:

• Endlosschleifen (Infinite Loops): Wenn die Abbruchbedingung niemals false werden kann, läuft die Schleife unendlich weiter. Das Programm friert ein oder stürzt ab. Die Ursache ist oft eine vergessene Inkrementierung (z. B. counter++ fehlt) innerhalb einer while-Schleife.
• Off-by-One-Fehler: Die Schleife läuft genau ein Mal zu viel oder zu wenig. Dies passiert meist durch die falsche Wahl der Vergleichsoperatoren (z. B. < statt <=) oder einen falschen Startwert (z. B. 1 statt 0 bei Arrays).

// Fehlerhaft (Off-by-One): Soll 3-mal laufen, läuft aber nur 2-mal
for (let i = 1; i < 3; i++) { 
    console.log(`Versuch ${i}`); // Gibt nur Versuch 1 und 2 aus
}

// Korrekt:
for (let i = 1; i <= 3; i++) { 
    console.log(`Versuch ${i}`); // Gibt Versuch 1, 2 und 3 aus
}

break: Der sofortige Notausstieg

Manchmal tritt ein Ereignis ein, das die weitere Ausführung der Schleife komplett überflüssig macht. Mit der Anweisung break kannst du eine Schleife sofort und vollständig beenden, auch wenn die eigentliche Abbruchbedingung noch nicht erreicht ist.

Stell dir vor, du suchst in einem Array mit tausenden Log-Einträgen nach einem spezifischen kritischen Fehler. Sobald du ihn gefunden hast, musst du die restlichen Einträge nicht mehr prüfen, um Rechenleistung zu sparen:

const fehlerCodes = [200, 404, 500, 403, 200];
const gesuchterFehler = 500;

for (const code of fehlerCodes) {
    console.log(`Prüfe Code: ${code}`);
    
    if (code === gesuchterFehler) {
        console.log("Kritischer Fehler gefunden! Suche wird abgebrochen.");
        break; // Verlässt die Schleife sofort
    }
}
// Das Programm springt direkt hierher weiter, ohne die 403 und 200 zu prüfen

continue: Die aktuelle Iteration überspringen

Wenn du die Schleife nicht komplett abbrechen, sondern nur den aktuellen Durchlauf (Iteration) vorzeitig beenden möchtest, nutzt du continue.

Der restliche Code im Schleifenrumpf wird für diese eine Runde übersprungen, und das Programm springt direkt zur nächsten Bedingungsprüfung (bzw. zum nächsten Element). Das ist extrem nützlich, um irrelevante Datenpunkte herauszufiltern, ohne die gesamte Schleife zu stoppen:

const netzwerkPakete = ["Daten", "Ping", "Daten", "Ping", "Daten"];
let verarbeiteteDaten = 0;

for (const paket of netzwerkPakete) {
    if (paket === "Ping") {
        // Pings ignorieren wir für die Zählung
        continue; // Springt sofort zum nächsten Element im Array
    }
    
    // Dieser Code wird bei "Ping" niemals erreicht
    verarbeiteteDaten++;
    console.log(`Datenpaket verarbeitet. Gesamt: ${verarbeiteteDaten}`);
}