Bedingte Anweisungen in TypeScript

In diesem Artikel werden wir bedingte Anweisungen in TypeScript erklären.

YouTube Video

If-Anweisungen in TypeScript

In TypeScript führt eine if-Anweisung eine Verzweigung aus, die Code ausführt, wenn eine angegebene Bedingung true ist, und ihn nicht ausführt, wenn die Bedingung false ist. Die if-Anweisung hat dieselbe Syntax wie in JavaScript und nutzt die Typensicherheit von TypeScript für bedingte Verzweigungen.

Grundlegende Syntax

Die grundlegende Syntax der if-Anweisung ist wie folgt.

1if (condition) {
2    // Code to execute if the condition is true
3} else if (anotherCondition) {
4    // Code to execute if the first condition is false
5    // and the another condition is true
6} else {
7    // Code to execute if all conditions are false
8}

• Wenn condition true ist, wird der Code im folgenden Block ausgeführt.
• Wenn condition false ist und anotherCondition true ist, wird der Code im folgenden Block ausgeführt.
• Wenn keine der Bedingungen true ist, wird der Code im abschließenden else-Block ausgeführt.

Beispiel 1: Grundlegende if-else-Anweisung

Im folgenden Beispiel wird überprüft, ob die Variable x 10 oder größer ist, und das Ergebnis ausgegeben.

1let x: number = 15;
2
3if (x >= 10) {
4    console.log("x is 10 or greater");
5} else {
6    console.log("x is less than 10");
7}
8// Outputs: x is 10 or greater

Beispiel 2: if-else if-else-Anweisung

Um mehrere Bedingungen zu überprüfen, verwenden Sie else if, um Verzweigungen hinzuzufügen.

 1let score: number = 85;
 2
 3if (score >= 90) {
 4    console.log("Excellent");
 5} else if (score >= 70) {
 6    console.log("Passed");
 7} else {
 8    console.log("Failed");
 9}
10// Outputs: Passed

Beispiel 3: if-Anweisung mit Typprüfung

Es ist auch möglich, mithilfe der Typprüfung von TypeScript bedingte Verzweigungen für bestimmte Typen durchzuführen. Überprüfen Sie beispielsweise den Typ einer Variablen mit dem typeof-Operator und führen Sie die entsprechende Verarbeitung durch.

 1let value: any = "Hello";
 2
 3if (typeof value === "string") {
 4    console.log("The value is a string: " + value);
 5} else if (typeof value === "number") {
 6    console.log("The value is a number: " + value);
 7} else {
 8    console.log("The value is of another type");
 9}
10// Outputs: "The value is a string: Hello"

Beispiel 4: Verschachtelte if-Anweisungen

Sie können if-Anweisungen auch verschachteln, um komplexe Bedingungen zu überprüfen.

 1let age: number = 25;
 2let isMember: boolean = true;
 3
 4if (age >= 18) {
 5    if (isMember) {
 6        console.log("You are a member and 18 years old or older");
 7    } else {
 8        console.log("You are not a member but 18 years old or older");
 9    }
10} else {
11    console.log("You are under 18 years old");
12}
13// Output
14// You are a member and 18 years old or older

Ternärer Operator (bedingter Operator)

Syntax

1condition ? valueIfTrue : valueIfFalse

Wenn Sie eine if-Anweisung kürzer schreiben möchten, können Sie den ternären Operator verwenden.

Beispiel

1const number: number = 7;
2const result: string = number % 2 === 0 ? "Even" : "Odd";
3console.log(result); // "Odd"

In diesem Fall, da number 7 ist, wird Odd angezeigt.

Zusammenfassung

• Die if-Anweisung ist eine grundlegende Steuerungsstruktur, um zu bestimmen, welche Verarbeitung basierend auf Bedingungen ausgeführt werden soll.
• Sie können mehrere Bedingungen mit else if behandeln.
• Durch die Verwendung von typeof können Sie die Typen von TypeScript für bedingte Verzweigungen nutzen.
• Die Handhabung komplexer Bedingungen ist mit verschachtelten if-Anweisungen möglich.
• Sie können den ternären Operator auch verwenden, um bedingte Verzweigungen prägnant zu schreiben.

In TypeScript kann die Verwendung von if-Anweisungen unter Berücksichtigung der Typensicherheit die Zuverlässigkeit des Codes verbessern.

Switch-Anweisungen in TypeScript

Die switch-Anweisung in TypeScript ist eine Steuerungsstruktur, die verwendet wird, um Code basierend auf mehreren Bedingungen zu verzweigen. Anstatt if-else if-Anweisungen zu verwenden, um mehrere Bedingungen zu bewerten, können Sie eine switch-Anweisung verwenden, um Verzweigungslogik basierend auf bestimmten Werten prägnant zu schreiben.

Grundlegende Syntax

 1switch (expressionToEvaluate) {
 2    case value1:
 3        // Code to execute if the expression evaluates to value1
 4        break;
 5    case value2:
 6        // Code to execute if the expression evaluates to value2
 7        break;
 8    default:
 9        // Code to execute if none of the conditions match
10}

In einer switch-Anweisung wird der case-Block ausgeführt, wenn der angegebene Wert in einem case mit dem ausgewerteten Ausdruck übereinstimmt. Achten Sie darauf, dass ohne ein break der nächste case-Block nacheinander ausgeführt wird. Der default-Block wird ausgeführt, wenn keine der case-Anweisungen übereinstimmt.

Beispiel 1: Grundlegende switch-Anweisung

Im folgenden Beispiel wird eine Zahl angegeben, die einen Wochentag (0 bis 6) darstellt, und der entsprechende Tagesname basierend auf diesem Wert ausgegeben.

 1let day: number = 3;
 2
 3switch (day) {
 4    case 0:
 5        console.log("Sunday");
 6        break;
 7    case 1:
 8        console.log("Monday");
 9        break;
10    case 2:
11        console.log("Tuesday");
12        break;
13    case 3:
14        console.log("Wednesday");
15        break;
16    case 4:
17        console.log("Thursday");
18        break;
19    case 5:
20        console.log("Friday");
21        break;
22    case 6:
23        console.log("Saturday");
24        break;
25    default:
26        console.log("Invalid day");
27}
28// Outputs: Wednesday

Beispiel 2: Beispiel mit default

default ist nützlich, da es ausgeführt wird, wenn keine der case-Anweisungen übereinstimmt, sodass Sie unerwartete Werte behandeln können.

 1let statusText: string = "pending";
 2
 3switch (statusText) {
 4    case "success":
 5        console.log("Operation succeeded");
 6        break;
 7    case "error":
 8        console.log("An error occurred");
 9        break;
10    case "pending":
11        console.log("Processing");
12        break;
13    default:
14        console.log("Unknown status");
15}
16// Outputs: Processing

Beispiel 3: Ausführen desselben Prozesses für mehrere cases

Wenn Sie dieselbe Aktion für mehrere case-Anweisungen ausführen möchten, können Sie diese hintereinander auflisten.

 1let fruit: string = "apple";
 2
 3switch (fruit) {
 4    case "apple":
 5    case "banana":
 6    case "orange":
 7        console.log("This is a fruit");
 8        break;
 9    default:
10        console.log("This is not a fruit");
11}
12// Outputs: This is a fruit

Beispiel 4: Verhalten, wenn break weggelassen wird

Das Weglassen eines break führt zu einem "Fall-through"-Verhalten, bei dem der nächste case ebenfalls ausgeführt wird.

 1let rank: number = 1;
 2
 3switch (rank) {
 4    case 1:
 5        console.log("Gold");
 6    case 2:
 7        console.log("Silver");
 8    case 3:
 9        console.log("Bronze");
10    default:
11        console.log("Not ranked");
12}
13// Outputs:
14// Gold
15// Silver
16// Bronze
17// Not ranked

Auf diese Weise wird nach einem übereinstimmenden case der nächste case ebenfalls ausgeführt, daher wird normalerweise ein break verwendet, um unnötiges Fall-through zu verhindern.

Zusammenfassung

• Die switch-Anweisung ist eine Kontrollstruktur, die es ermöglicht, Verzweigungslogik basierend auf mehreren Bedingungen prägnant zu schreiben.
• Jeder case sollte den Prozess ausdrücklich durch ein break beenden.
• Der default-Block wird ausgeführt, wenn keine der cases übereinstimmt.
• Es ist auch möglich, dieselbe Operation für mehrere cases auszuführen.

Die switch-Anweisung in TypeScript ist nützlich, um mehrere Bedingungen effizient zu behandeln und dabei die Lesbarkeit des Codes beizubehalten.

Sie können den obigen Artikel mit Visual Studio Code auf unserem YouTube-Kanal verfolgen. Bitte schauen Sie sich auch den YouTube-Kanal an.

YouTube Video