Kontrollstrukturen

Geschätzte Lektüre: 10 Minuten 582 Ansichten

Kontrollstrukturen bilden das Rückgrat jeder Programmiersprache und ermöglichen es, den Ablauf eines Programms dynamisch zu steuern. In JavaScript sind diese Strukturen besonders vielseitig und mächtig. Sie erlauben es uns, Entscheidungen zu treffen, Code wiederholt auszuführen und komplexe Abläufe logisch zu strukturieren.

Grundlegende Konzepte von Kontrollstrukturen

Bevor wir in die Details einsteigen, ist es wichtig zu verstehen, was Kontrollstrukturen überhaupt sind. Im Kern handelt es sich um Anweisungen, die den Kontrollfluss eines Programms bestimmen – also die Reihenfolge, in der Anweisungen ausgeführt werden. Ohne Kontrollstrukturen würde ein Programm einfach Zeile für Zeile von oben nach unten abgearbeitet werden, was für die meisten realen Anwendungen völlig unzureichend wäre.

JavaScript bietet drei Hauptkategorien von Kontrollstrukturen:
• Bedingte Anweisungen (if, else, switch)
• Schleifen (for, while, do…while)
• Sprunganweisungen (break, continue, return)

Bedingte Anweisungen: Entscheidungen im Code

Die if-Anweisung

Die einfachste Form der Entscheidungsfindung ist die if-Anweisung. Sie überprüft eine Bedingung und führt den folgenden Codeblock nur aus, wenn diese Bedingung wahr (true) ist.

let alter = 18;

if (alter >= 18) {
    console.log("Sie sind volljährig.");
}

In diesem Beispiel wird die Nachricht nur ausgegeben, wenn die Variable alter den Wert 18 oder größer enthält. Die Bedingung steht in runden Klammern (), der auszuführende Codeblock in geschweiften Klammern {}.

if…else: Alternative Wege

Oft möchte man nicht nur auf eine Bedingung reagieren, sondern auch einen alternativen Codeblock für den Fall bereithalten, dass die Bedingung nicht erfüllt ist. Hier kommt else ins Spiel.

let punktzahl = 45;

if (punktzahl >= 50) {
    console.log("Bestanden!");
} else {
    console.log("Leider nicht bestanden.");
}

else if: Mehrere Bedingungen prüfen

Für komplexere Entscheidungsbäume kann man else if verwenden, um mehrere Bedingungen nacheinander zu prüfen.

let note = 2.3;

if (note === 1) {
    console.log("Ausgezeichnet!");
} else if (note <= 2) {
    console.log("Sehr gut!");
} else if (note <= 3) {
    console.log("Gut");
} else if (note <= 4) {
    console.log("Befriedigend");
} else {
    console.log("Nicht bestanden");
}

Die switch-Anweisung

Für Fälle, in denen viele verschiedene Werte einer einzelnen Variable überprüft werden sollen, eignet sich die switch-Anweisung besser als eine lange Kette von if…else if-Statements.

let wochentag = "Dienstag";

switch(wochentag) {
    case "Montag":
        console.log("Wochenstart");
        break;
    case "Dienstag":
    case "Mittwoch":
    case "Donnerstag":
        console.log("Arbeitswoche");
        break;
    case "Freitag":
        console.log("Fast Wochenende");
        break;
    case "Samstag":
    case "Sonntag":
        console.log("Wochenende");
        break;
    default:
        console.log("Ungültiger Wochentag");
}

Wichtige Punkte bei switch:
• Jeder case wird mit break abgeschlossen (sonst „fällt“ die Ausführung durch)
• default wird ausgeführt, wenn kein anderer Fall zutrifft
• Cases können gruppiert werden (wie bei Dienstag-Mittwoch-Donnerstag)

Schleifen: Code wiederholt ausführen

Schleifen ermöglichen es, einen Codeblock mehrfach auszuführen – eine der mächtigsten Fähigkeiten in der Programmierung.

Die for-Schleife

Die for-Schleife ist ideal, wenn man genau weiß, wie oft eine Anweisung wiederholt werden soll.

for (let i = 0; i < 5; i++) {
    console.log("Durchlauf Nummer: " + i);
}

Eine for-Schleife besteht aus drei Teilen:
• Initialisierung (let i = 0): Wird einmal am Anfang ausgeführt
• Bedingung (i < 5): Vor jedem Durchlauf geprüft
• Inkrement (i++): Wird nach jedem Durchlauf ausgeführt

    Die while-Schleife

    Die while-Schleife führt einen Codeblock aus, solange eine Bedingung wahr ist.

    let zaehler = 0;

while (zaehler < 5) {
    console.log("Zähler steht bei: " + zaehler);
    zaehler++;
}

    Wichtig ist, dass die Bedingung sich irgendwann ändert, sonst entsteht eine Endlosschleife.

    Die do…while-Schleife

    Ähnlich wie while, aber der Codeblock wird mindestens einmal ausgeführt, bevor die Bedingung geprüft wird.

    let eingabe;

do {
    eingabe = prompt("Bitte 'ja' eingeben:");
} while (eingabe !== 'ja');

    Besondere Schleifen-Konstrukte: for…in und for…of

    JavaScript bietet spezielle Schleifen für Objekte und Arrays:

    for…in iteriert über die Eigenschaften eines Objekts:

    const person = {name: "Max", alter: 30, beruf: "Entwickler"};

for (let eigenschaft in person) {
    console.log(`${eigenschaft}: ${person[eigenschaft]}`);
}

    for…of iteriert über die Werte iterierbarer Objekte (Arrays, Strings etc.):

    const farben = ["rot", "grün", "blau"];

for (let farbe of farben) {
    console.log(farbe);
}

    Sprunganweisungen: Den Kontrollfluss steuern

    Manchmal möchte man den normalen Ablauf von Schleifen oder Funktionen unterbrechen oder ändern.

    break: Schleifen vorzeitig beenden

    break beendet die aktuelle Schleife sofort.

    for (let i = 0; i < 10; i++) {
    if (i === 5) {
        break;
    }
    console.log(i); // 0, 1, 2, 3, 4
}

    continue: Den aktuellen Durchlauf überspringen

    continue überspringt den restlichen Code des aktuellen Schleifendurchlaufs.

    for (let i = 0; i < 5; i++) {
    if (i === 2) {
        continue;
    }
    console.log(i); // 0, 1, 3, 4
}

    return: Werte aus Funktionen zurückgeben

    return beendet eine Funktion und gibt optional einen Wert zurück.

    function istVolljaehrig(alter) {
    if (alter >= 18) {
        return true;
    }
    return false;
}

    Ternärer Operator: Kompakte Bedingungen

    Für einfache if-else-Strukturen bietet JavaScript den ternären Operator als Kurzform.

    let alter = 20;
let status = (alter >= 18) ? "volljährig" : "minderjährig";

    Dies entspricht:

    let status;
if (alter >= 18) {
    status = "volljährig";
} else {
    status = "minderjährig";
}

    Fehlerbehandlung mit try-catch

    Eine besondere Form der Kontrollstruktur ist try-catch für die Fehlerbehandlung.

    try {
    // Code, der Fehler verursachen könnte
    let ergebnis = nichtDefinierteVariable / 0;
} catch (fehler) {
    console.log("Ein Fehler ist aufgetreten: " + fehler.message);
} finally {
    console.log("Dies wird immer ausgeführt");
}

    Fortgeschrittene Konzepte

    Verschachtelte Kontrollstrukturen

    Kontrollstrukturen können beliebig verschachtelt werden, um komplexe Logik abzubilden.

    for (let i = 1; i <= 10; i++) {
    if (i % 2 === 0) {
        console.log(i + " ist gerade");
        if (i % 4 === 0) {
            console.log("Und durch 4 teilbar!");
        }
    } else {
        console.log(i + " ist ungerade");
    }
}

    Kurzschlussauswertung (Short-Circuit Evaluation)

    JavaScript nutzt Kurzschlusslogik bei logischen Operatoren, was für elegante Kontrollstrukturen genutzt werden kann.

    let einstellung = benutzereinstellung || "Standardwert";

    Praxisbeispiel: Einfacher Taschenrechner

    function rechner(operation, a, b) {
    switch(operation) {
        case '+':
            return a + b;
        case '-':
            return a - b;
        case '*':
            return a * b;
        case '/':
            if (b === 0) {
                console.log("Division durch Null nicht möglich");
                return NaN;
            }
            return a / b;
        default:
            console.log("Ungültige Operation");
            return NaN;
    }
}

let ergebnis = rechner('+', 5, 3); // 8

    Essentiell

    Kontrollstrukturen sind essentiell für die Erstellung dynamischer, interaktiver JavaScript-Anwendungen. Von einfachen if-Abfragen bis hin zu komplexen verschachtelten Schleifen bieten sie die Werkzeuge, um jeden erdenklichen Programmablauf zu modellieren. Die Kunst liegt darin, die richtige Struktur für das jeweilige Problem zu wählen und dabei den Code lesbar und wartbar zu halten. Mit der Beherrschung dieser Konzepte haben Sie einen der wichtigsten Grundpfeiler der JavaScript-Programmierung verstanden.

    Dieses Dokument teilen

    Kontrollstrukturen

    Oder Link kopieren

    INHALT

    Abonnieren

    ×
    Cancel