Verzweigungen

Geschätzte Lektüre: 11 Minuten 377 Ansichten

Verzweigungen sind ein fundamentales Konzept in der Programmierung, das es ermöglicht, den Ablauf eines Programms basierend auf bestimmten Bedingungen zu steuern. In JavaScript gibt es mehrere Möglichkeiten, Verzweigungen zu implementieren, von einfachen if-Anweisungen bis hin zu komplexen Bäumen von Entscheidungslogik.

Grundlagen der Verzweigungen

Das Prinzip von Verzweigungen basiert auf der Auswertung von Bedingungen (conditions), die entweder wahr (true) oder falsch (false) sein können. Je nach Ergebnis dieser Auswertung wird ein bestimmter Codeblock ausgeführt oder übersprungen. Diese Logik entspricht den Entscheidungen, die wir täglich treffen: „Wenn es regnet, nehme ich einen Regenschirm mit, sonst nicht.“

Die if-Anweisung

Die einfachste Form der Verzweigung ist die if-Anweisung. Sie besteht aus dem Schlüsselwort if, gefolgt von einer Bedingung in runden Klammern und einem Codeblock in geschweiften Klammern, der ausgeführt wird, wenn die Bedingung wahr 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 alter >= 18 wird zu true ausgewertet, wenn die Aussage zutrifft.

Die if…else-Anweisung

Oft möchte man nicht nur eine Aktion ausführen, wenn eine Bedingung wahr ist, sondern auch eine alternative Aktion für den Fall, dass sie falsch ist. Dafür dient die else-Klausel.

let temperatur = 25;

if (temperatur > 30) {
    console.log("Es ist sehr heiß!");
} else {
    console.log("Die Temperatur ist angenehm.");
}

Hier wird der erste Block ausgeführt, wenn die Temperatur über 30°C liegt, andernfalls der zweite Block.

Mehrfache Verzweigungen mit else if

Für komplexere Entscheidungen mit mehr als zwei Möglichkeiten verwendet man else if:

let uhrzeit = 14;

if (uhrzeit < 12) {
    console.log("Guten Morgen!");
} else if (uhrzeit < 18) {
    console.log("Guten Tag!");
} else {
    console.log("Guten Abend!");
}

Die Bedingungen werden von oben nach unten ausgewertet. Sobald eine Bedingung wahr ist, wird der entsprechende Block ausgeführt und der Rest übersprungen. In diesem Beispiel würde „Guten Tag!“ ausgegeben werden, da 14 Uhr nach 12 Uhr, aber vor 18 Uhr liegt.

Ternärer Operator (Bedingte Operator)

Für einfache Verzweigungen gibt es eine kompakte Schreibweise, den ternären Operator:

let punktzahl = 85;
let bestanden = punktzahl >= 50 ? "bestanden" : "nicht bestanden";

console.log(bestanden); // Ausgabe: "bestanden"

Die Syntax ist: Bedingung ? AusdruckWennWahr : AusdruckWennFalsch. Dies ist besonders nützlich für Zuweisungen oder kurze Rückgabewerte.

Switch-Anweisung

Wenn viele Fälle basierend auf dem gleichen Wert unterschiedlich behandelt werden sollen, ist eine switch-Anweisung oft übersichtlicher als mehrere if…else if-Anweisungen.

let wochentag = 3;
let tagName;

switch (wochentag) {
    case 1:
        tagName = "Montag";
        break;
    case 2:
        tagName = "Dienstag";
        break;
    case 3:
        tagName = "Mittwoch";
        break;
    case 4:
        tagName = "Donnerstag";
        break;
    case 5:
        tagName = "Freitag";
        break;
    case 6:
        tagName = "Samstag";
        break;
    case 7:
        tagName = "Sonntag";
        break;
    default:
        tagName = "Ungültiger Tag";
}

console.log(tagName); // Ausgabe: "Mittwoch"

Wichtige Punkte zur switch-Anweisung:
• case definiert die verschiedenen Fälle
• break beendet den switch-Block (ohne break würde die Ausführung in den nächsten Fall „durchfallen“)
• default wird ausgeführt, wenn kein Fall zutrifft (optional)

Logische Operatoren in Bedingungen

Bedingungen können mit logischen Operatoren kombiniert werden:
• && (UND): Beide Bedingungen müssen wahr sein
• || (ODER): Mindestens eine Bedingung muss wahr sein
• ! (NICHT): Invertiert den Wahrheitswert

Truthy und Falsy Werte

In JavaScript werden nicht nur explizite true oder false Werte in Bedingungen ausgewertet. Jeder Wert hat einen impliziten „Truthy“ oder „Falsy“ Wert.

Falsy Werte (werden zu false ausgewertet):
• false
• 0, -0
• „“ (leerer String)
• null
• undefined
• NaN

Alle anderen Werte sind Truthy (werden zu true ausgewertet).

let name = "";

if (name) {
    console.log(`Hallo ${name}`);
} else {
    console.log("Bitte Namen eingeben!");
    // Wird ausgeführt, weil leerer String falsy ist
}

Verschachtelte Verzweigungen

Verzweigungen können ineinander verschachtelt werden, um komplexe Logiken abzubilden:

let alter = 20;
let elternEinverstanden = true;

if (alter >= 18) {
    console.log("Volljährig - darf teilnehmen.");
} else {
    if (elternEinverstanden) {
        console.log("Darf mit Einverständnis der Eltern teilnehmen.");
    } else {
        console.log("Darf nicht teilnehmen.");
    }
}

Kurzschlussauswertung (Short-Circuit Evaluation)

JavaScript nutzt Kurzschlussauswertung bei logischen Operatoren:
• Bei &&: Wenn der erste Wert falsy ist, wird er zurückgegeben, sonst der zweite
• Bei ||: Wenn der erste Wert truthy ist, wird er zurückgegeben, sonst der zweite

Dies kann für elegante Verzweigungen genutzt werden:

let username = "";
let defaultName = "Gast";

// Wenn username falsy ist, wird defaultName verwendet
let anzeigeName = username || defaultName;

console.log(anzeigeName); // Ausgabe: "Gast"

Typische Anwendungsfälle

• Formularvalidierung

function validiereEmail(email) {
    if (!email.includes("@")) {
        return "Ungültige E-Mail: Muss @ enthalten";
    }
    if (email.length < 5) {
        return "E-Mail zu kurz";
    }
    return "E-Mail gültig";
}

• Zugriffskontrolle:

let benutzerRolle = "admin";
let istEingeloggt = true;

if (istEingeloggt &&
(benutzerRolle === "admin" || benutzerRolle === "moderator")) {
    console.log("Zugang zum Admin-Bereich gewährt");
} else {
    console.log("Zugriff verweigert");
}

• Preisberechnung:

function berechnePreis(menge, istMitglied) {
    let grundpreis = menge * 10;
    let rabatt = 0;
    
    if (menge > 100) {
        rabatt = 0.2;
    } else if (menge > 50) {
        rabatt = 0.1;
    }
    
    if (istMitglied) {
        rabatt += 0.05; // Zusätzlicher Mitgliederrabatt
    }
    
    return grundpreis * (1 - rabatt);
}

Fortgeschrittene Konzepte

Bedingte Verzweigungen mit Objekten

Für komplexe Verzweigungen kann man statt vieler if/else oder switch-Anweisungen ein Objekt mit Funktionen verwenden:

const rechner = {
    addieren: (a, b) => a + b,
    subtrahieren: (a, b) => a - b,
    multiplizieren: (a, b) => a * b,
    dividieren: (a, b) => a / b
};

function berechne(operation, a, b) {
    const operationFn = rechner[operation];
    if (operationFn) {
        return operationFn(a, b);
    }
    return "Unbekannte Operation";
}

console.log(berechne("addieren", 5, 3)); // 8

Optional Chaining mit Verzweigungen

Modernes JavaScript (ES2020+) bietet Optional Chaining (?.), das mit Verzweigungen kombiniert werden kann:

const user = {
    profile: {
        name: "Alice",
        address: {
            city: "Berlin"
        }
    }
};

if (user?.profile?.address?.city) {
    console.log(`Stadt: ${user.profile.address.city}`);
} else {
    console.log("Stadt nicht verfügbar");
}

Performance-Überlegungen

Bei sehr vielen Verzweigungen kann die Reihenfolge der Bedingungen die Performance beeinflussen:
• Häufig zutreffende Bedingungen sollten zuerst geprüft werden
• Bei ||-Verknüpfungen die wahrscheinlichste Bedingung zuerst
• Bei &&-Verknüpfungen die unwahrscheinlichste Bedingung zuerst

// Optimierte Reihenfolge
if (häufigeBedingung || selteneBedingung) {
    // Häufige Bedingung wird zuerst geprüft
}

if (unwahrscheinlicheBedingung && wahrscheinlicheBedingung) {
    // Bei && wird bei falschem Wert abgebrochen
}

Das Rückgrat der Programmsteuerung

Verzweigungen sind das Rückgrat der Programmsteuerung in JavaScript. Von einfachen if-Anweisungen bis zu komplexen verschachtelten Strukturen ermöglichen sie die Implementierung von Entscheidungslogik in Programmen. Die Wahl der richtigen Verzweigungsstruktur (if/else, switch, ternärer Operator) hängt von der spezifischen Situation ab und beeinflusst Lesbarkeit und Wartbarkeit des Codes. Durch das Verständnis von truthy/falsy Werten, logischen Operatoren und fortgeschrittenen Mustern können Entwickler präzise und effiziente Bedingungen formulieren.

Die Kunst liegt darin, ein Gleichgewicht zwischen klarer Lesbarkeit und optimaler Performance zu finden, während komplexe Logiken in verständliche, gut strukturierte Codeblöcke zerlegt werden. Mit den dargestellten Konzepten und Best Practices sind Sie gut gerüstet, um effektive Verzweigungen in Ihren JavaScript-Projekten zu implementieren.

Dieses Dokument teilen

Verzweigungen

Oder Link kopieren

INHALT

Abonnieren

×
Cancel